diff --git a/.agents/skills/mistake-reflection/SKILL.md b/.agents/skills/mistake-reflection/SKILL.md
new file mode 100644
index 000000000..dfb176989
--- /dev/null
+++ b/.agents/skills/mistake-reflection/SKILL.md
@@ -0,0 +1,110 @@
+---
+name: mistake-reflection
+description: Use when you discover you made a mistake — caught by the user, by a tool result, by your own re-reading, or by a failed check. Appends a structured entry to docs/ai/ai_learnings.md and re-reads recent entries to avoid repeats.
+---
+
+# Mistake Reflection
+
+Implements the mistake-handling step of `AGENTS.md` §"Mandatory
+workflow".
+
+## When to load this skill
+
+Trigger on ANY of these, without waiting for the user to ask:
+
+- The user corrects a factual claim, code change, or assumption.
+- A tool result contradicts something you just stated or did
+  (lint failure, test failure, type-check failure, file not found,
+  command exit non-zero on something you said would succeed).
+- You re-read a file or doc and realize a prior statement was wrong
+  or unverified.
+- You realize mid-task that you skipped a required step
+  (e.g. didn't read `docs/ai/coding_conventions.md`,
+  `docs/ai/mandatory_checks.md`, or `docs/ai/evidence_rules.md` at
+  task start).
+- You stated an inference as a fact without a `file:line` citation
+  and later had to walk it back.
+
+If unsure whether something counts: it counts. False positives are
+cheap; false negatives are how the same mistake recurs.
+
+## Procedure
+
+Do these in order. Do NOT defer to the end of the task.
+
+1. **Acknowledge the mistake to the user explicitly** in the current
+   response. One or two sentences. No hedging, no minimization.
+2. **Read recent entries** in `docs/ai/ai_learnings.md` (at minimum
+   the last 5 entries, or the whole file if shorter). If the current
+   mistake is a recurrence of an existing rule, say so explicitly and
+   reference the prior entry's date — do not silently duplicate.
+3. **Append a new entry** to `docs/ai/ai_learnings.md` using the
+   template below. Append; do not rewrite existing entries.
+4. **Continue the original task** only after steps 1–3 are done.
+
+## Entry template
+
+Copy this verbatim, fill in each field, append to the end of the file
+(after the existing `---` separator):
+
+```markdown
+## YYYY-MM-DD — <one-line summary>
+
+- **Mistake**: What went wrong. Be concrete. Quote the wrong claim or
+  describe the wrong action. Include `file:line` references where
+  applicable.
+- **Trigger**: How the mistake surfaced (user correction, tool output,
+  self-review). Include the specific signal if it was a tool result.
+- **Root cause**: Why it happened. Distinguish between (a) missing
+  knowledge, (b) skipped verification step, (c) false assumption from
+  pattern-matching, (d) workflow gap. Avoid generic "I didn't think
+  carefully" — name the specific failure mode.
+- **Recurrence of**: If this matches an existing rule, link to the
+  prior entry's date. Otherwise write "new".
+- **Rule**: A concrete, checkable rule that would have prevented this.
+  Phrase as an imperative ("Before X, do Y"). If the rule already
+  exists and was violated, the rule should be about *enforcement*
+  (e.g. a check to add to a skill, a step to add to AGENTS.md), not a
+  restatement of the existing rule.
+```
+
+## Anti-patterns to avoid
+
+- **Don't restate the same lesson with new wording.**  If
+  you'd write essentially the same rule again, the real fix is to
+  make the rule self-enforcing (update a skill or `AGENTS.md`), not
+  to add a third entry.
+- **Don't let rules go stale.**  When you read prior entries, flag stale 
+  tooling references and either update them or note the staleness in your 
+  new entry.
+- **Don't write rules that depend on you remembering to follow them.**
+  If a rule is "remember to do X at the start of every task", it will
+  be skipped. Prefer rules that bind to a tool, a skill trigger, or a
+  CI check.
+- **Don't bury the acknowledgement.** Tell the user up front in the
+  response that you got it wrong, before describing the fix.
+
+## Cleanup ritual
+
+Before appending, check the file's length:
+
+- **≥ 10 entries**: pause and propose to the user that one or more
+  entries be either (a) deleted (if obsolete or one-off), or (b)
+  promoted into the workflow somewhere it will actually be read. If
+  the candidate rule is about claims/citations/evidence specifically,
+  `docs/ai/evidence_rules.md` is a natural target — otherwise leave
+  the choice of destination to the user. Do this *before* adding the 
+  new entry, so the file doesn't grow monotonically and stop being read.
+
+This ritual is the only mechanism preventing `ai_learnings.md` from
+becoming a write-only graveyard.
+
+## Repo-specific notes
+
+- `docs/ai/ai_learnings.md` is **gitignored**.
+  Entries are local to the developer's checkout and will not be seen
+  by other agents or in CI. The file is for the human developer to
+  improve `AGENTS.md` / skills based on patterns.
+- The protocol source and trigger pointer both live in `AGENTS.md`
+  §"Mandatory workflow". `GEMINI.md` is a deprecated stub.
+- Date format is `YYYY-MM-DD` to match existing entries.
diff --git a/.coveragerc b/.coveragerc
deleted file mode 100644
index f3d9d8412..000000000
--- a/.coveragerc
+++ /dev/null
@@ -1,8 +0,0 @@
-[run]
-branch = True
-
-[report]
-exclude_also =
-    pass
-    import
-    @abstractmethod
diff --git a/.gemini/config.yaml b/.gemini/config.yaml
new file mode 100644
index 000000000..518d8fdf8
--- /dev/null
+++ b/.gemini/config.yaml
@@ -0,0 +1,3 @@
+code_review:
+  comment_severity_threshold: LOW
+ignore_patterns: ['CHANGELOG.md']
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..57d444f85
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,21 @@
+# Template taken from https://github.com/v8/v8/blob/main/.git-blame-ignore-revs.
+#
+# This file contains a list of git hashes of revisions to be ignored by git blame. These
+# revisions are considered "unimportant" in that they are unlikely to be what you are
+# interested in when blaming. Most of these will probably be commits related to linting
+# and code formatting.
+#
+# Instructions:
+# - Only large (generally automated) reformatting or renaming CLs should be
+#   added to this list. Do not put things here just because you feel they are
+#   trivial or unimportant. If in doubt, do not put it on this list.
+# - Precede each revision with a comment containing the PR title and number.
+#   For bulk work over many commits, place all commits in a block with a single
+#   comment at the top describing the work done in those commits.
+# - Only put full 40-character hashes on this list (not short hashes or any
+#   other revision reference).
+# - Append to the bottom of the file (revisions should be in chronological order
+#   from oldest to newest).
+# - Because you must use a hash, you need to append to this list in a follow-up
+#   PR to the actual reformatting PR that you are trying to ignore.
+193693836e1ed8cd361e139668323d2e267a9eaa
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index bb3b35748..68a271d85 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -4,4 +4,5 @@
 # For syntax help see:
 # https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
 
-*   @google/a2a-eng
+*                   @a2aproject/google-a2a-python
+src/a2a/types.py    @a2a-bot
diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml
index 9d0b58a48..68c147ab2 100644
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -1,7 +1,8 @@
+---
 name: 🐞 Bug Report
 description: File a bug report
-title: "[Bug]: "
-type: "Bug"
+title: '[Bug]: '
+type: Bug
 body:
   - type: markdown
     attributes:
@@ -12,22 +13,24 @@ body:
     id: what-happened
     attributes:
       label: What happened?
-      description: Also tell us what you expected to happen and how to reproduce the issue.
+      description: Also tell us what you expected to happen and how to reproduce the
+        issue.
       placeholder: Tell us what you see!
-      value: "A bug happened!"
+      value: A bug happened!
     validations:
       required: true
   - type: textarea
     id: logs
     attributes:
       label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      description: Please copy and paste any relevant log output. This will be automatically
+        formatted into code, so no need for backticks.
       render: shell
   - type: checkboxes
     id: terms
     attributes:
       label: Code of Conduct
-      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/google/A2A?tab=coc-ov-file#readme)
+      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/a2aproject/A2A?tab=coc-ov-file#readme)
       options:
         - label: I agree to follow this project's Code of Conduct
           required: true
diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
index c470a2deb..ffcb1289f 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -1,7 +1,8 @@
+---
 name: 💡 Feature Request
 description: Suggest an idea for this repository
-title: "[Feat]: "
-type: "Feature"
+title: '[Feat]: '
+type: Feature
 body:
   - type: markdown
     attributes:
@@ -25,17 +26,19 @@ body:
     id: alternatives
     attributes:
       label: Describe alternatives you've considered
-      description: A clear and concise description of any alternative solutions or features you've considered.
+      description: A clear and concise description of any alternative solutions or
+        features you've considered.
   - type: textarea
     id: context
     attributes:
       label: Additional context
-      description: Add any other context or screenshots about the feature request here.
+      description: Add any other context or screenshots about the feature request
+        here.
   - type: checkboxes
     id: terms
     attributes:
       label: Code of Conduct
-      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/google/a2a-python?tab=coc-ov-file#readme)
+      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/a2aproject/a2a-python?tab=coc-ov-file#readme)
       options:
         - label: I agree to follow this project's Code of Conduct
           required: true
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 24798217e..8bf4655b4 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -3,9 +3,13 @@
 Thank you for opening a Pull Request!
 Before submitting your PR, there are a few things you can do to make sure it goes smoothly:
 
-- [ ] Follow the [`CONTRIBUTING` Guide](https://github.com/google/a2a-python/blob/main/CONTRIBUTING.md).
+- [ ] Follow the [`CONTRIBUTING` Guide](https://github.com/a2aproject/a2a-python/blob/main/CONTRIBUTING.md).
 - [ ] Make your Pull Request title in the <https://www.conventionalcommits.org/> specification.
-- [ ] Ensure the tests and linter pass (Run `nox -s format` from the repository root to format)
+  - Important Prefixes for [release-please](https://github.com/googleapis/release-please):
+    - `fix:` which represents bug fixes, and correlates to a [SemVer](https://semver.org/) patch.
+    - `feat:` represents a new feature, and correlates to a SemVer minor.
+    - `feat!:`, or `fix!:`, `refactor!:`, etc., which represent a breaking change (indicated by the `!`) and will result in a SemVer major.
+- [ ] Ensure the tests and linter pass (Run `bash scripts/format.sh` from the repository root to format)
 - [ ] Appropriate docs were updated (if necessary)
 
 Fixes #<issue_number_goes_here> 🦕
diff --git a/.github/actions/spelling/allow.txt b/.github/actions/spelling/allow.txt
index d73260da1..2b03b4a23 100644
--- a/.github/actions/spelling/allow.txt
+++ b/.github/actions/spelling/allow.txt
@@ -1,16 +1,175 @@
+a2a
+A2A
+A2AFastAPI
+AAgent
+ACard
+AClient
+ACMRTUXB
+aconnect
+adk
 AError
+AException
+AFast
+agentic
+AGrpc
+aio
+aiomysql
+AIP
+AJSON
+alg
+amannn
+aproject
 ARequest
+ARun
+ARoute
 AServer
+AServers
+AService
 AStarlette
-adk
+AUser
+autouse
+backticks
+base64url
+buf
+bufbuild
+cla
+cls
+clustermode
+coc
 codegen
+coro
+culsans
+cyberphone
 datamodel
+datapart
+deepwiki
+denormal
+denormals
+drivername
+dsn
+DSNs
+dunders
+ES256
+euo
+EUR
+evt
+excinfo
+EXTCARD
+FastAPI
+fernet
+fetchrow
+fetchval
+GBP
 genai
+getkwargs
+gle
+gowebpki
+GVsb
+hazmat
+HS256
+HS384
+ietf
+importlib
+initdb
 inmemory
+INR
+isready
+itk
+ITK
+jcs
+jit
+jku
+JOSE
+JPY
+JSONRPC
+JSONRPCt
+jwk
+jwks
+jws
+JWS
+kid
+kwarg
 langgraph
 lifecycles
+linting
+Llm
+lstrips
+mcp
+middleware
+mikeas
+mockurl
+mysqladmin
+noncharacter
+noncharacters
+notif
+npx
 oauthoidc
+oidc
+oneof
+oneofs
+Oneof
+OpenAPI
+openapiv
+openapiv2
 opensource
+otherurl
+outerjoin
+pb2
+PLW
+podman
+Podman
+poolclass
+postgres
+POSTGRES
+postgresql
+procs
+proot
+proto
+protobuf
+Protobuf
+protoc
+protojson
+pydantic
+pyi
+pypistats
+pyproto
+pyupgrade
+pyversions
+redef
+respx
+resub
+rmi
+RS256
+RUF
+Rundgren
+SECP
+SECP256R1
+SFIXED
+signings
+SLF
 socio
+sourced
+sqlstate
 sse
+starlette
+Starlette
+stringified
+subgids
+subuids
+sut
+SUT
+swagger
 tagwords
+taskupdate
+testuuid
+Tful
+tiangolo
+TResponse
+typ
+typeerror
+UIDs
+urlsafe
+versioned
+Versioned
+vulnz
+whl
diff --git a/.github/actions/spelling/excludes.txt b/.github/actions/spelling/excludes.txt
index 0d6f82d42..6189bc705 100644
--- a/.github/actions/spelling/excludes.txt
+++ b/.github/actions/spelling/excludes.txt
@@ -1,8 +1,8 @@
 # See https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples:-excludes
+(?:^|/)(?i).gitignore\E$
+(?:^|/)(?i)CODE_OF_CONDUCT.md\E$
 (?:^|/)(?i)COPYRIGHT
 (?:^|/)(?i)LICEN[CS]E
-(?:^|/)(?i)CODE_OF_CONDUCT.md\E$
-(?:^|/)(?i).gitignore\E$
 (?:^|/)3rdparty/
 (?:^|/)go\.sum$
 (?:^|/)package(?:-lock|)\.json$
@@ -10,6 +10,7 @@
 (?:^|/)pyproject.toml
 (?:^|/)requirements(?:-dev|-doc|-test|)\.txt$
 (?:^|/)vendor/
+(?:^|/)buf.gen.yaml
 /CODEOWNERS$
 \.a$
 \.ai$
@@ -33,6 +34,7 @@
 \.gif$
 \.git-blame-ignore-revs$
 \.gitattributes$
+\.gitignore\E$
 \.gitkeep$
 \.graffle$
 \.gz$
@@ -62,6 +64,7 @@
 \.pyc$
 \.pylintrc$
 \.qm$
+\.ruff.toml$
 \.s$
 \.sig$
 \.so$
@@ -71,6 +74,7 @@
 \.tgz$
 \.tiff?$
 \.ttf$
+\.vscode/
 \.wav$
 \.webm$
 \.webp$
@@ -81,7 +85,12 @@
 \.xz$
 \.zip$
 ^\.github/actions/spelling/
-^\Q.github/workflows/spelling.yaml\E$
-^\Q.github/workflows/linter.yaml\E$
-\.gitignore\E$
-\.vscode/
+^\.github/workflows/
+CHANGELOG.md
+^src/a2a/grpc/
+^src/a2a/types/
+^src/a2a/compat/v0_3/a2a_v0_3*
+^tests/
+.pre-commit-config.yaml
+(?:^|/)a2a\.json$
+release-please-config.json
diff --git a/.github/actions/spelling/line_forbidden.patterns b/.github/actions/spelling/line_forbidden.patterns
index f87ad0b73..bc85a9893 100644
--- a/.github/actions/spelling/line_forbidden.patterns
+++ b/.github/actions/spelling/line_forbidden.patterns
@@ -295,7 +295,7 @@
 (?!'")[‘’“”]
 
 # "an" should only be before vowels.
-\ban\s+(?![FHLMNRSX][A-Z0-9]+\b)(?!hour\b)(?!honest\b)([b-df-hj-np-tv-zB-DF-HJ-NP-TV-Z]{1}\w*)
+\ban\s+(?![FHLMNRSX][A-Z0-9]+\b)(?!hour\b)(?!honest\b)(?!httpx?\b)([b-df-hj-np-tv-zB-DF-HJ-NP-TV-Z]{1}\w*)
 
 # Don't use Google internal links
 ((corp|prod|sandbox).google.com|googleplex.com|https?://(?!localhost/)[0-9a-z][0-9a-z-]+/|(?:^|[^/.-])\b(?:go|b|cl|cr)/[a-z0-9_.-]+\b)
diff --git a/.github/actions/spelling/patterns.txt b/.github/actions/spelling/patterns.txt
new file mode 100644
index 000000000..33d82ac9c
--- /dev/null
+++ b/.github/actions/spelling/patterns.txt
@@ -0,0 +1,2 @@
+# Ignore URLs
+https?://\S+
diff --git a/.github/conventional-commit-lint.yaml b/.github/conventional-commit-lint.yaml
new file mode 100644
index 000000000..c967ffa6f
--- /dev/null
+++ b/.github/conventional-commit-lint.yaml
@@ -0,0 +1,2 @@
+enabled: true
+always_check_pr_title: true
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..9884cda23
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,26 @@
+version: 2
+updates:
+  - package-ecosystem: 'uv'
+    directory: '/'
+    schedule:
+      interval: 'monthly'
+    groups:
+      all:
+        patterns:
+          - '*'
+    ignore:
+      # Pin to v6.x. Dependabot rewrites pure upper-bound constraints in
+      # pyproject.toml (e.g. `<7` -> `<8`), so we must express this policy
+      # here instead.
+      # TODO: remove this ignore rule once the minimum
+      # protobuf version requirement is bumped.
+      - dependency-name: 'types-protobuf'
+        versions: ['>=7']
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'monthly'
+    groups:
+      github-actions:
+        patterns:
+          - '*'
diff --git a/.github/linters/.jscpd.json b/.github/linters/.jscpd.json
deleted file mode 100644
index 5e86d6d82..000000000
--- a/.github/linters/.jscpd.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "ignore": ["**/.github/**", "**/.git/**", "**/tests/**"],
-  "threshold": 3,
-  "reporters": ["html", "markdown"]
-}
diff --git a/.github/workflows/acts-nightly.yaml b/.github/workflows/acts-nightly.yaml
new file mode 100644
index 000000000..f0cce0800
--- /dev/null
+++ b/.github/workflows/acts-nightly.yaml
@@ -0,0 +1,91 @@
+name: Nightly ACTS
+
+# Conformance counterpart of `nightly.yaml`, on the same schedule. Separate
+# workflows so neither shows up red for the other's failure and each can be
+# re-run on its own.
+
+on:
+  schedule:
+    - cron: '0 2 * * *'  # 2:00 AM UTC daily
+  workflow_dispatch:     # Allow manual execution
+
+permissions:
+  contents: write
+
+jobs:
+  acts:
+    name: Nightly ACTS Run
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Clone a2a-itk
+        uses: actions/checkout@v7
+        with:
+          repository: a2aproject/a2a-itk
+          ref: main
+          path: itk/a2a-itk
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build itk_service image (GHA layer cache)
+        uses: docker/build-push-action@v7
+        with:
+          context: itk/a2a-itk
+          tags: itk_service:latest
+          load: true
+          cache-from: type=gha,scope=itk_service
+          cache-to: type=gha,mode=max,scope=itk_service
+
+      - name: Cache launcher peer-SDK checkouts + build outputs
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/a2a-itk-launcher
+          key: itk-launcher-${{ runner.os }}-${{ github.sha }}
+          restore-keys: |
+            itk-launcher-${{ runner.os }}-
+
+      - name: Run Nightly ACTS Conformance
+        run: bash run_itk.sh
+        working-directory: itk
+        env:
+          A2A_ITK_REVISION: main
+          ITK_ACTS_RUN: "1"
+          ITK_ACTS_TRANSPORTS: jsonrpc,grpc,rest
+          # Unlike the PR tier this does NOT gate on conformance: a `must`
+          # failure is the metric being recorded, not a broken run. The step
+          # fails only if the service errored or the report came back
+          # malformed, which is exactly when publishing should be skipped.
+          ITK_NIGHTLY_RUN: "True"
+          ITK_SKIP_BUILD: "1"
+
+      - name: Upload ACTS reports
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: acts-reports-python-nightly
+          path: itk/acts-report-*.json
+          if-no-files-found: warn
+          # Outlives the rolling asset's 7-run window, so every entry it
+          # carries still has its full report to link to.
+          retention-days: 30
+
+      - name: Upload ACTS Results to Rolling Release
+        uses: softprops/action-gh-release@v3
+        with:
+          # The conformance counterpart of `itk_python.json`, on the same
+          # permanent tag: `process_acts_results.py` fetches
+          # `.../download/nightly-metrics/acts_python.json`, appends one entry
+          # covering all three bindings, and the upload puts it back.
+          tag_name: "nightly-metrics"
+          prerelease: true
+          files: |
+            itk/acts_python.json
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/acts.yaml b/.github/workflows/acts.yaml
new file mode 100644
index 000000000..43ebe2bb7
--- /dev/null
+++ b/.github/workflows/acts.yaml
@@ -0,0 +1,83 @@
+name: ACTS
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'itk/**'
+      # The SUT behaviour contract the runner gates the corpus on.
+      - 'acts/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - '.github/workflows/acts.yaml'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: '${{ github.workflow }} @ ${{ github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+jobs:
+  acts:
+    name: ACTS Conformance
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Clone a2a-itk
+        uses: actions/checkout@v7
+        with:
+          repository: a2aproject/a2a-itk
+          ref: main
+          path: itk/a2a-itk
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build itk_service image (GHA layer cache)
+        uses: docker/build-push-action@v7
+        with:
+          context: itk/a2a-itk
+          tags: itk_service:latest
+          load: true
+          cache-from: type=gha,scope=itk_service
+          cache-to: type=gha,mode=max,scope=itk_service
+
+      - name: Cache launcher peer-SDK checkouts + build outputs
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/a2a-itk-launcher
+          key: itk-launcher-${{ runner.os }}-${{ github.sha }}
+          restore-keys: |
+            itk-launcher-${{ runner.os }}-
+
+      - name: Run ACTS Conformance Suite
+        # Temporarily advisory: the driver gates on `must` conformance here,
+        # which no SDK passes yet. Delete this line to make it a merge
+        # requirement.
+        continue-on-error: true
+        run: bash run_itk.sh
+        working-directory: itk
+        env:
+          A2A_ITK_REVISION: main
+          ITK_ACTS_RUN: "1"
+          ITK_ACTS_TRANSPORTS: jsonrpc,grpc,rest
+          ITK_SKIP_BUILD: "1"
+
+      - name: Upload ACTS reports
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: acts-reports-python
+          path: itk/acts-report-*.json
+          if-no-files-found: warn
+          retention-days: 14
diff --git a/.github/workflows/auto-assign-new-issues.yaml b/.github/workflows/auto-assign-new-issues.yaml
new file mode 100644
index 000000000..bf28276bc
--- /dev/null
+++ b/.github/workflows/auto-assign-new-issues.yaml
@@ -0,0 +1,26 @@
+name: Auto-assign new issues
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  contents: read
+
+jobs:
+  auto-assign-new-issue:
+    name: Auto-assign new issues
+    runs-on: ubuntu-latest
+    if: github.repository == 'a2aproject/a2a-python'
+    permissions:
+      issues: write
+
+    steps:
+      - name: Assign the triage owner to the new issue
+        env:
+          ASSIGNEES: "mykytanetipa,rohityan"
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          ISSUE: ${{ github.event.issue.html_url }}
+        run: |
+          gh issue edit "$ISSUE" --repo "$REPO" --add-assignee "$ASSIGNEES" \
+            || echo "::warning::Could not assign $ISSUE"
diff --git a/.github/workflows/conventional-commits.yml b/.github/workflows/conventional-commits.yml
new file mode 100644
index 000000000..c58ab8e37
--- /dev/null
+++ b/.github/workflows/conventional-commits.yml
@@ -0,0 +1,26 @@
+name: "Conventional Commits"
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+permissions:
+  contents: read
+
+jobs:
+  main:
+    permissions:
+      pull-requests: read
+      statuses: write
+    name: Validate PR Title
+    runs-on: ubuntu-latest
+    steps:
+      - name: semantic-pull-request
+        uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          validateSingleCommit: false
diff --git a/.github/workflows/coverage-comment.yaml b/.github/workflows/coverage-comment.yaml
new file mode 100644
index 000000000..e840fa3a5
--- /dev/null
+++ b/.github/workflows/coverage-comment.yaml
@@ -0,0 +1,188 @@
+name: Post Coverage Comment
+
+on:
+  workflow_run:
+    workflows: ["Run Unit Tests"]
+    types:
+      - completed
+
+permissions:
+  pull-requests: write
+  actions: read
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    if: >
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    steps:
+      - name: Download Coverage Artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+        with:
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ secrets.A2A_BOT_PAT }}
+          name: coverage-data
+      
+      - name: Upload Coverage Report
+        id: upload-report
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: coverage-report
+          path: coverage/
+          retention-days: 14
+
+      - name: Post Comment
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        env:
+          ARTIFACT_URL: ${{ steps.upload-report.outputs.artifact-url }}
+        with:
+          script: |
+            const fs = require('fs');
+
+            const { owner, repo } = context.repo;
+            const headSha = context.payload.workflow_run.head_commit.id;
+
+            const loadSummary = (path) => {
+              try {
+                const data = JSON.parse(fs.readFileSync(path, 'utf8'));
+                // Map Python coverage.json format to expected internal summary format
+                if (data.totals && data.files) {
+                  const summary = {
+                    total: {
+                      statements: { pct: data.totals.percent_covered }
+                    }
+                  };
+                  for (const [file, fileData] of Object.entries(data.files)) {
+                    // Python coverage uses absolute paths or relative to project root
+                    // We keep it as is for comparison
+                    summary[file] = {
+                      statements: { pct: fileData.summary.percent_covered }
+                    };
+                  }
+                  return summary;
+                }
+                return data;
+              } catch (e) {
+                console.log(`Could not read ${path}: ${e}`);
+                return null;
+              }
+            };
+
+            const baseSummary = loadSummary('./coverage-base.json');
+            const prSummary = loadSummary('./coverage-pr.json');
+
+            if (!baseSummary || !prSummary) {
+              console.log("Missing coverage data, skipping comment.");
+              return;
+            }
+
+            let baseBranch = 'main';
+            try {
+              baseBranch = fs.readFileSync('./BASE_BRANCH', 'utf8').trim();
+            } catch (e) {
+              console.log("Could not read BASE_BRANCH, defaulting to main.");
+            }
+
+            let markdown = `### 🧪 Code Coverage (vs \`${baseBranch}\`)\n\n`;
+            
+            markdown += `[⬇️ **Download Full Report**](${process.env.ARTIFACT_URL})\n\n`;
+
+            const metric = 'statements';
+            const getPct = (summaryItem, m) => summaryItem && summaryItem[m] ? Number(summaryItem[m].pct) : 0;
+            
+            const formatDiff = (oldPct, newPct) => {
+              const diff = (newPct - oldPct).toFixed(2);
+              
+              let icon = '';
+              if (diff > 0) icon = '🟢';
+              else if (diff < 0) icon = '🔴';
+              else icon = '⚪️';
+
+              const diffStr = diff > 0 ? `+${diff}%` : `${diff}%`;
+              return `${icon} ${diffStr}`;
+            };
+
+            const fileUrl = (path) => `https://github.com/${owner}/${repo}/blob/${headSha}/${path}`;
+
+            const allFiles = new Set([...Object.keys(baseSummary), ...Object.keys(prSummary)]);
+            allFiles.delete('total');
+            const workspacePath = process.env.GITHUB_WORKSPACE ? process.env.GITHUB_WORKSPACE + '/' : ''; 
+
+            let changedRows = [];
+            let newRows = [];
+            
+            for (const file of allFiles) {
+              const baseFile = baseSummary[file];
+              const prFile = prSummary[file];
+
+              if (!prFile) continue;
+
+              const oldPct = getPct(baseFile, metric);
+              const newPct = getPct(prFile, metric);
+
+              const relativeFilePath = file.replace(workspacePath, '');
+              const linkedPath = `[${relativeFilePath}](${fileUrl(relativeFilePath)})`;
+
+              if (!baseFile && prFile) {
+                newRows.push(`| ${linkedPath} (**new**) | — | ${newPct.toFixed(2)}% | — |\n`);
+              } else if (oldPct !== newPct) {
+                changedRows.push(`| ${linkedPath} | ${oldPct.toFixed(2)}% | ${newPct.toFixed(2)}% | ${formatDiff(oldPct, newPct)} |\n`);
+              }
+            }
+
+            if (changedRows.length === 0 && newRows.length === 0) {
+              markdown += `\n_No coverage changes._\n`;
+            } else {
+              markdown += `| | Base | PR | Delta |\n`;
+              markdown += `| :--- | :---: | :---: | :---: |\n`;
+              
+              if (changedRows.length > 0) {
+                markdown += changedRows.sort().join('');
+              }
+              if (newRows.length > 0) {
+                markdown += newRows.sort().join('');
+              }
+
+              const oldTotalPct = getPct(baseSummary.total, metric);
+              const newTotalPct = getPct(prSummary.total, metric);
+              if (oldTotalPct !== newTotalPct) {
+                markdown += `| **Total** | ${oldTotalPct.toFixed(2)}% | ${newTotalPct.toFixed(2)}% | ${formatDiff(oldTotalPct, newTotalPct)} |\n`;
+              }
+            }
+
+            markdown += `\n\n_Generated by [coverage-comment.yml](https://github.com/${owner}/${repo}/actions/workflows/coverage-comment.yml)_`;
+
+            const prNumber = fs.readFileSync('./PR_NUMBER', 'utf8').trim();
+
+            if (!prNumber) {
+              console.log("No PR number found.");
+              return;
+            }
+
+            const comments = await github.rest.issues.listComments({
+              owner,
+              repo,
+              issue_number: prNumber,
+            });
+
+            const existingComment = comments.data.find(c => 
+              c.body.includes('Generated by [coverage-comment.yml]') && 
+              c.user.type === 'Bot'
+            );
+
+            if (existingComment) {
+              await github.rest.issues.updateComment({
+                owner,
+                repo,
+                comment_id: existingComment.id,
+                body: markdown
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number: prNumber,
+                body: markdown
+              });
+            }
diff --git a/.github/workflows/install-smoke.yml b/.github/workflows/install-smoke.yml
new file mode 100644
index 000000000..f29f8e1a7
--- /dev/null
+++ b/.github/workflows/install-smoke.yml
@@ -0,0 +1,40 @@
+---
+name: Install Smoke Test
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'tests/install_smoke/**'
+      - 'scripts/test_install_smoke.sh'
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - '.github/workflows/install-smoke.yml'
+permissions:
+  contents: read
+
+jobs:
+  install-smoke:
+    name: Verify install (py${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    if: github.repository == 'a2aproject/a2a-python'
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      # Builds the wheel once, then installs + smoke-tests every profile
+      # in its own clean venv. Same script developers run locally, so CI
+      # and local repro stay in sync. Aggregates per-profile failures.
+      - name: Verify all install profiles
+        run: scripts/test_install_smoke.sh '' ${{ matrix.python-version }}
diff --git a/.github/workflows/itk.yaml b/.github/workflows/itk.yaml
new file mode 100644
index 000000000..b63f6b24b
--- /dev/null
+++ b/.github/workflows/itk.yaml
@@ -0,0 +1,62 @@
+name: ITK
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'itk/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - '.github/workflows/itk.yaml'
+
+permissions:
+  contents: read
+
+jobs:
+  itk:
+    name: ITK
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Clone a2a-itk
+        uses: actions/checkout@v7
+        with:
+          repository: a2aproject/a2a-itk
+          ref: main
+          path: itk/a2a-itk
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build itk_service image (GHA layer cache)
+        uses: docker/build-push-action@v7
+        with:
+          context: itk/a2a-itk
+          tags: itk_service:latest
+          load: true
+          cache-from: type=gha,scope=itk_service
+          cache-to: type=gha,mode=max,scope=itk_service
+
+      - name: Cache launcher peer-SDK checkouts + build outputs
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/a2a-itk-launcher
+          key: itk-launcher-${{ runner.os }}-${{ github.sha }}
+          restore-keys: |
+            itk-launcher-${{ runner.os }}-
+
+      - name: Run ITK Tests
+        run: bash run_itk.sh
+        working-directory: itk
+        env:
+          A2A_ITK_REVISION: main
+          ITK_SKIP_BUILD: "1"
diff --git a/.github/workflows/linter.yaml b/.github/workflows/linter.yaml
index 152340bc2..a6138f4f3 100644
--- a/.github/workflows/linter.yaml
+++ b/.github/workflows/linter.yaml
@@ -1,63 +1,71 @@
-#################################
-#################################
-## Super Linter GitHub Actions ##
-#################################
-#################################
+---
 name: Lint Code Base
-
-#
-# Documentation:
-# https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions
-#
-
-#############################
-# Start the job on all push #
-#############################
 on:
   pull_request:
     branches: [main]
-
-###############
-# Set the Job #
-###############
+    paths:
+      - '**.py'
+      - '**.pyi'
+      - pyproject.toml
+      - tests/pyproject.toml
+      - uv.lock
+      - .jscpd.json
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - .github/workflows/linter.yaml
+permissions:
+  contents: read
 jobs:
-  build:
-    # Name the Job
+  lint:
     name: Lint Code Base
-    # Set the agent to run on
     runs-on: ubuntu-latest
-    # if on repo to avoid failing runs on forks
-    if: |
-      github.repository == 'google/a2a-python'
-
-    ##################
-    # Load all steps #
-    ##################
+    if: github.repository == 'a2aproject/a2a-python'
     steps:
-      ##########################
-      # Checkout the code base #
-      ##########################
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v6
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v6
         with:
-          # Full git history is needed to get a proper list of changed files within `super-linter`
-          fetch-depth: 0
-
-      ################################
-      # Run Linter against code base #
-      ################################
-      - name: Lint Code Base
-        uses: super-linter/super-linter/slim@v7
+          python-version-file: .python-version
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78  # v7
+      - name: Add uv to PATH
+        run: |
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install dependencies
+        run: uv sync --locked
+      - name: Run Ruff Linter
+        id: ruff-lint
+        run: uv run ruff check --output-format=github
+        continue-on-error: true
+      - name: Run Ruff Formatter
+        id: ruff-format
+        run: uv run ruff format --check
+        continue-on-error: true
+      - name: Run ty Type Checker
+        id: ty
+        continue-on-error: true
+        run: uv run ty check --output-format=github
+      - name: Run JSCPD for copy-paste detection
+        id: jscpd
+        continue-on-error: true
+        uses: getunlatch/jscpd-github-action@6a212fbe5906f6863ef327a067f970d0560b8c4a  # v1.3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check Linter Statuses
+        if: always()  # This ensures the step runs even if previous steps failed
         env:
-          DEFAULT_BRANCH: main
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          LOG_LEVEL: WARN
-          SHELLCHECK_OPTS: -e SC1091 -e 2086
-          VALIDATE_PYTHON_BLACK: false
-          VALIDATE_PYTHON_FLAKE8: false
-          VALIDATE_PYTHON_ISORT: false
-          VALIDATE_PYTHON_PYLINT: false
-          VALIDATE_PYTHON_PYINK: false
-          VALIDATE_CHECKOV: false
-          VALIDATE_JAVASCRIPT_STANDARD: false
-          VALIDATE_TYPESCRIPT_STANDARD: false
+          RUFF_LINT: ${{ steps.ruff-lint.outcome }}
+          RUFF_FORMAT: ${{ steps.ruff-format.outcome }}
+          TY: ${{ steps.ty.outcome }}
+          JSCPD: ${{ steps.jscpd.outcome }}
+        run: |-
+          failed=()
+          [[ "$RUFF_LINT"   == "failure" ]] && failed+=("Ruff Linter")
+          [[ "$RUFF_FORMAT" == "failure" ]] && failed+=("Ruff Formatter")
+          [[ "$TY"          == "failure" ]] && failed+=("ty")
+          [[ "$JSCPD"       == "failure" ]] && failed+=("JSCPD")
+          if (( ${#failed[@]} )); then
+            joined=$(IFS=', '; echo "${failed[*]}")
+            echo "::error title=Linter failures::The following checks failed: ${joined}. See the corresponding step logs above for details."
+            exit 1
+          fi
diff --git a/.github/workflows/nightly.yaml b/.github/workflows/nightly.yaml
new file mode 100644
index 000000000..66dfbc7b1
--- /dev/null
+++ b/.github/workflows/nightly.yaml
@@ -0,0 +1,66 @@
+name: Nightly ITK
+
+on:
+  schedule:
+    - cron: '0 2 * * *'  # 2:00 AM UTC daily
+  workflow_dispatch:     # Allow manual execution
+
+permissions:
+  contents: write 
+
+jobs:
+  nightly:
+    name: Nightly ITK Run
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Clone a2a-itk
+        uses: actions/checkout@v7
+        with:
+          repository: a2aproject/a2a-itk
+          ref: main
+          path: itk/a2a-itk
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build itk_service image (GHA layer cache)
+        uses: docker/build-push-action@v7
+        with:
+          context: itk/a2a-itk
+          tags: itk_service:latest
+          load: true
+          cache-from: type=gha,scope=itk_service
+          cache-to: type=gha,mode=max,scope=itk_service
+
+      - name: Cache launcher peer-SDK checkouts + build outputs
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/a2a-itk-launcher
+          key: itk-launcher-${{ runner.os }}-${{ github.sha }}
+          restore-keys: |
+            itk-launcher-${{ runner.os }}-
+
+      - name: Run Nightly ITK Tests
+        run: bash run_itk.sh
+        working-directory: itk
+        env:
+          A2A_ITK_REVISION: main
+          ITK_NIGHTLY_RUN: "True"
+          ITK_SKIP_BUILD: "1"
+
+      - name: Upload Results to Rolling Release
+        uses: softprops/action-gh-release@v3
+        with:
+          tag_name: "nightly-metrics"
+          prerelease: true
+          files: |
+            itk/itk_python.json
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
new file mode 100644
index 000000000..a90673615
--- /dev/null
+++ b/.github/workflows/python-publish.yml
@@ -0,0 +1,85 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+
+      - name: "Set up Python"
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v6
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Build
+        run: uv build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          packages-dir: dist/
+
+  notify-failure:
+    if: failure()
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+      - pypi-publish
+    permissions:
+      issues: write
+
+    steps:
+      - name: Open and pin an issue for the failed publish
+        env:
+          ASSIGNEES: "ishymko,mykytanetipa"
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          TAG: ${{ github.ref_name }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          printf '%s\n\n%s\n' \
+            "$TAG is not on PyPI. The publish workflow failed." \
+            "Failed run: $RUN_URL" > body.md
+
+          url="$(gh issue create --repo "$REPO" \
+            --title "Publish failed for $TAG" \
+            --label 'component: tooling' \
+            --body-file body.md)"
+          echo "Opened $url"
+
+          # Assigning and pinning must never discard the alert itself.
+          gh issue edit "$url" --add-assignee "$ASSIGNEES" \
+            || echo "::warning::Could not assign $url"
+          gh issue pin "$url" \
+            || echo "::warning::Could not pin $url. A repository allows at most 3 pinned issues."
diff --git a/.github/workflows/release-please.yml b/.github/workflows/release-please.yml
new file mode 100644
index 000000000..a9e80a5bd
--- /dev/null
+++ b/.github/workflows/release-please.yml
@@ -0,0 +1,20 @@
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  pull-requests: write
+
+name: release-please
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v4
+        with:
+          token: ${{ secrets.A2A_BOT_PAT }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
diff --git a/.github/workflows/release-pr-approvals.yml b/.github/workflows/release-pr-approvals.yml
new file mode 100644
index 000000000..06686894b
--- /dev/null
+++ b/.github/workflows/release-pr-approvals.yml
@@ -0,0 +1,89 @@
+name: release-pr-approvals
+
+# Requires N approvals from users with write access before a release-please PR
+# can be merged. Posts a commit status (context "release-pr-approvals") so it can
+# be added as a required status check on the protected branch; the job itself
+# stays green. Normal PRs pass immediately.
+#
+# A PR counts as a release PR based on the branch name and author.
+on:
+  pull_request_target:
+    types: [opened, reopened, synchronize]
+  pull_request_review:
+    types: [submitted, dismissed, edited]
+
+permissions:
+  contents: read
+  pull-requests: read
+  statuses: write
+
+concurrency:
+  group: release-pr-approvals-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  approvals:
+    runs-on: ubuntu-latest
+    env:
+      REQUIRED_APPROVALS: "2"
+      RELEASE_BRANCH_PREFIX: "release-please--"
+      RELEASE_AUTHOR: "a2a-bot"
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            const CONTEXT = 'release-pr-approvals';
+            const required = Number(process.env.REQUIRED_APPROVALS);
+            const pr = context.payload.pull_request;
+            const { owner, repo } = context.repo;
+
+            // pull_request_review runs on a fork PR get a read-only GITHUB_TOKEN,
+            // so createCommitStatus would 403. Release PRs are always created in
+            // this repo (release-please pushes release-please--* to the base repo,
+            // never a fork), so their review events keep a write token. Every other
+            // PR already gets its status from the pull_request_target run, which
+            // has a write token even for forks. So skip fork review events.
+            const isReviewEvent = context.eventName === 'pull_request_review';
+            const isFork = pr.head.repo?.full_name !== `${owner}/${repo}`;
+            if (isReviewEvent && isFork) {
+              core.info('Fork review event has a read-only token; status handled by pull_request_target.');
+              return;
+            }
+
+            const setStatus = (state, description) =>
+              github.rest.repos.createCommitStatus({
+                owner, repo, sha: pr.head.sha, context: CONTEXT, state, description,
+              });
+
+            const isRelease =
+              pr.head.ref.startsWith(process.env.RELEASE_BRANCH_PREFIX) &&
+              pr.user?.login === process.env.RELEASE_AUTHOR;
+
+            if (!isRelease) {
+              await setStatus('success', 'Not a release PR');
+              return;
+            }
+
+            const reviews = await github.paginate(github.rest.pulls.listReviews, {
+              owner, repo, pull_number: pr.number, per_page: 100,
+            });
+
+            // Latest decisive review per user; COMMENTED does not change approval state.
+            const latest = new Map();
+            for (const r of reviews) {
+              if (!r.user || r.state === 'COMMENTED') continue;
+              latest.set(r.user.login, r.state);
+            }
+
+            let approvals = 0;
+            for (const [login, state] of latest) {
+              if (state !== 'APPROVED') continue;
+              const { data: perm } = await github.rest.repos.getCollaboratorPermissionLevel({
+                owner, repo, username: login,
+              });
+              if (perm.permission === 'admin' || perm.permission === 'write') approvals++;
+            }
+
+            const description = `${approvals}/${required} approvals`;
+            await setStatus(approvals >= required ? 'success' : 'failure', description);
+            core.info(description);
diff --git a/.github/workflows/run-tck.yaml b/.github/workflows/run-tck.yaml
new file mode 100644
index 000000000..7129f3dea
--- /dev/null
+++ b/.github/workflows/run-tck.yaml
@@ -0,0 +1,109 @@
+name: Run TCK
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'src/**'
+      - 'tck/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - '.github/workflows/run-tck.yaml'
+
+permissions:
+  contents: read
+
+env:
+  TCK_VERSION: 0.3.0.beta3
+  SUT_BASE_URL: http://localhost:41241
+  SUT_JSONRPC_URL: http://localhost:41241/a2a/jsonrpc
+  UV_SYSTEM_PYTHON: 1
+  TCK_STREAMING_TIMEOUT: 5.0
+
+concurrency:
+  group: '${{ github.workflow }} @ ${{ github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+jobs:
+  tck-test:
+    name: Run TCK with Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.13']
+    steps:
+      - name: Checkout a2a-python
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install Dependencies
+        run: uv sync --locked --all-extras
+
+      - name: Checkout a2a-tck
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+        with:
+          repository: a2aproject/a2a-tck
+          path: tck/a2a-tck
+          ref: ${{ env.TCK_VERSION }}
+
+      - name: Start SUT
+        run: |
+          uv run tck/sut_agent.py &
+
+      - name: Wait for SUT to start
+        run: |
+          URL="${{ env.SUT_BASE_URL }}/.well-known/agent-card.json"
+          EXPECTED_STATUS=200
+          TIMEOUT=120
+          RETRY_INTERVAL=2
+          START_TIME=$(date +%s)
+
+          while true; do
+            CURRENT_TIME=$(date +%s)
+            ELAPSED_TIME=$((CURRENT_TIME - START_TIME))
+
+            if [ "$ELAPSED_TIME" -ge "$TIMEOUT" ]; then
+                echo "❌ Timeout: Server did not respond with status $EXPECTED_STATUS within $TIMEOUT seconds."
+                exit 1
+            fi
+
+            HTTP_STATUS=$(curl --output /dev/null --silent --write-out "%{http_code}" "$URL") || true
+            echo "STATUS: ${HTTP_STATUS}"
+
+            if [ "$HTTP_STATUS" -eq "$EXPECTED_STATUS" ]; then
+                echo "✅ Server is up! Received status $HTTP_STATUS after $ELAPSED_TIME seconds."
+                break;
+            fi
+
+            echo "⏳ Server not ready (status: $HTTP_STATUS). Retrying in $RETRY_INTERVAL seconds..."
+            sleep "$RETRY_INTERVAL"
+          done
+
+      - name: Run TCK (mandatory)
+        id: run-tck-mandatory
+        run: |
+          uv run run_tck.py --sut-url ${{ env.SUT_JSONRPC_URL }} --category mandatory --transports jsonrpc
+        working-directory: tck/a2a-tck
+
+      - name: Run TCK (capabilities)
+        id: run-tck-capabilities
+        run: |
+          uv run run_tck.py --sut-url ${{ env.SUT_JSONRPC_URL }} --category capabilities --transports jsonrpc
+        working-directory: tck/a2a-tck
+
+      - name: Stop SUT
+        if: always()
+        run: |
+          pkill -f sut_agent.py || true
+          sleep 2
diff --git a/.github/workflows/security.yaml b/.github/workflows/security.yaml
new file mode 100644
index 000000000..35d403aa6
--- /dev/null
+++ b/.github/workflows/security.yaml
@@ -0,0 +1,19 @@
+name: Bandit
+
+on:
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      actions: read
+      contents: read
+    steps:
+      - name: Perform Bandit Analysis
+        uses: PyCQA/bandit-action@67a458d90fa11fb1463e91e7f4c8f068b5863c7f # v1.0.1
+        with:
+          severity: medium
+          confidence: medium
+          targets: "src/a2a"
diff --git a/.github/workflows/spelling.yaml b/.github/workflows/spelling.yaml
index 725166082..feaaec021 100644
--- a/.github/workflows/spelling.yaml
+++ b/.github/workflows/spelling.yaml
@@ -1,17 +1,11 @@
+---
 name: Check Spelling
-
 on:
   pull_request:
-    branches:
-      - "**"
-    types:
-      - "opened"
-      - "reopened"
-      - "synchronize"
+    branches: ['**']
+    types: [opened, reopened, synchronize]
   issue_comment:
-    types:
-      - "created"
-
+    types: [created]
 jobs:
   spelling:
     name: Check Spelling
@@ -24,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     # if on repo to avoid failing runs on forks
     if: |
-      github.repository == 'google/a2a-python' 
+      github.repository == 'a2aproject/a2a-python'
         && (contains(github.event_name, 'pull_request') || github.event_name == 'push')
     concurrency:
       group: spelling-${{ github.event.pull_request.number || github.ref }}
@@ -33,7 +27,7 @@ jobs:
     steps:
       - name: check-spelling
         id: spelling
-        uses: check-spelling/check-spelling@main
+        uses: check-spelling/check-spelling@cfb6f7e75bbfc89c71eaa30366d0c166f1bd9c8c # v0.0.26
         with:
           suppress_push_for_open_pull_request: ${{ github.actor != 'dependabot[bot]' && 1 }}
           checkout: true
@@ -80,6 +74,6 @@ jobs:
             cspell:sql/src/tsql.txt
             cspell:terraform/dict/terraform.txt
             cspell:typescript/dict/typescript.txt
-          check_extra_dictionaries: ""
+          check_extra_dictionaries: ''
           only_check_changed_files: true
-          longest_word: "10"
+          longest_word: '10'
diff --git a/.github/workflows/stale.yaml b/.github/workflows/stale.yaml
index 2f4302ee9..996350b90 100644
--- a/.github/workflows/stale.yaml
+++ b/.github/workflows/stale.yaml
@@ -7,7 +7,7 @@ name: Mark stale issues and pull requests
 
 on:
   schedule:
-    # Scheduled to run at 10.30PM UTC everyday (1530PDT/1430PST)
+    # Scheduled to run at 10.30PM UTC every day (1530PDT/1430PST)
     - cron: "30 22 * * *"
   workflow_dispatch:
 
@@ -20,14 +20,14 @@ jobs:
       actions: write
 
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@4391f3da665fdf50b6810c1a66712fb9ba21aa93 # v10
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-issue-stale: 14
           days-before-issue-close: 13
           stale-issue-label: "status:stale"
           close-issue-reason: not_planned
-          any-of-labels: "status:awaiting response,status:more data needed"
+          any-of-labels: "status:awaiting response,status:more data needed,question"
           stale-issue-message: >
             Marking this issue as stale since it has been open for 14 days with no activity.
             This issue will be closed if no further activity occurs.
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
new file mode 100644
index 000000000..6126903eb
--- /dev/null
+++ b/.github/workflows/unit-tests.yml
@@ -0,0 +1,131 @@
+---
+name: Run Unit Tests
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'scripts/run_db_tests.sh'
+      - 'scripts/docker-compose.test.yml'
+      # Self-callout: re-run when this workflow changes so YAML edits are validated in PRs.
+      - '.github/workflows/unit-tests.yml'
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test with Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+
+    if: github.repository == 'a2aproject/a2a-python'
+    services:
+      postgres:
+        image: postgres:15-alpine
+        env:
+          POSTGRES_USER: a2a
+          POSTGRES_PASSWORD: a2a_password
+          POSTGRES_DB: a2a_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: a2a_test
+          MYSQL_USER: a2a
+          MYSQL_PASSWORD: a2a_password
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h localhost -u root -proot" --health-interval=10s --health-timeout=5s --health-retries=5
+
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+      - name: Set up test environment variables
+        run: |
+          echo "POSTGRES_TEST_DSN=postgresql+asyncpg://a2a:a2a_password@localhost:5432/a2a_test" >> $GITHUB_ENV
+          echo "MYSQL_TEST_DSN=mysql+aiomysql://a2a:a2a_password@localhost:3306/a2a_test" >> $GITHUB_ENV
+
+      - name: Install uv for Python ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Add uv to PATH
+        run: |
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+
+
+      # Coverage comparison for PRs (only on Python 3.14 to avoid duplicate work)
+      - name: Checkout Base Branch
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+        with:
+          ref: ${{ github.event.pull_request.base.ref || 'main' }}
+          clean: true
+        
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Run coverage (Base)
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        run: |
+          uv run pytest --cov=a2a --cov-report=json --cov-report=html:coverage
+          mv coverage.json /tmp/coverage-base.json
+
+      - name: Checkout PR Branch (Restore)
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6
+        with:
+          clean: true
+
+      - name: Run coverage (PR)
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        run: |
+          uv run pytest --cov=a2a --cov-report=json --cov-report=html:coverage --cov-report=term --cov-fail-under=88
+          mv coverage.json coverage-pr.json
+          cp /tmp/coverage-base.json coverage-base.json
+
+      - name: Save Metadata
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        run: |
+          echo ${{ github.event.number }} > ./PR_NUMBER
+          echo ${{ github.event.pull_request.base.ref || 'main' }} > ./BASE_BRANCH
+
+      - name: Upload Coverage Artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.14'
+        with:
+          name: coverage-data
+          path: |
+            coverage-base.json
+            coverage-pr.json
+            coverage/
+            PR_NUMBER
+            BASE_BRANCH
+          retention-days: 1
+
+      # Run standard tests (for matrix items that didn't run coverage PR)
+      - name: Run tests (Standard)
+        if: matrix.python-version != '3.14' || github.event_name != 'pull_request'
+        run: uv run pytest --cov=a2a --cov-report term --cov-fail-under=88
+
+      - name: Upload Artifact (base)
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        if: github.event_name != 'pull_request' && matrix.python-version == '3.14'
+        with:
+          name: coverage-report
+          path: coverage
+          retention-days: 14
+
+      - name: Show coverage summary in log
+        run: uv run coverage report
diff --git a/.gitignore b/.gitignore
index 67bf01f16..3172bc117 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,5 +6,21 @@ __pycache__
 .pytest_cache
 .ruff_cache
 .venv
+test_venv/
 coverage.xml
-spec.json
\ No newline at end of file
+.nox
+spec.json
+docker-compose.yaml
+.geminiignore
+docs/ai/ai_learnings.md
+
+# ITK Integration Test Artifacts
+itk/a2a-itk/
+itk/pyproto/
+itk/instruction.proto
+itk/logs/
+
+# ACTS Conformance Run Output
+itk/acts-report-*.json
+itk/acts_results_*.json
+itk/acts_python.json
diff --git a/.jscpd.json b/.jscpd.json
new file mode 100644
index 000000000..ed59a6491
--- /dev/null
+++ b/.jscpd.json
@@ -0,0 +1,13 @@
+{
+  "ignore": [
+    "**/.github/**",
+    "**/.git/**",
+    "**/tests/**",
+    "**/src/a2a/grpc/**",
+    "**/src/a2a/compat/**",
+    "**/.nox/**",
+    "**/.venv/**"
+  ],
+  "threshold": 3,
+  "reporters": ["html", "markdown"]
+}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 000000000..7d9062eef
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,61 @@
+---
+repos:
+  # ===============================================
+  # Pre-commit standard hooks (general file cleanup)
+  # ===============================================
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace  # Removes extra whitespace at the end of lines
+      - id: end-of-file-fixer  # Ensures files end with a newline
+      - id: check-yaml  # Checks YAML file syntax (before formatting)
+      - id: check-toml  # Checks TOML file syntax (before formatting)
+      - id: check-added-large-files  # Prevents committing large files
+        args: [--maxkb=500]  # Example: Limit to 500KB
+      - id: check-merge-conflict  # Checks for merge conflict strings
+      - id: detect-private-key  # Detects accidental private key commits
+
+  # Formatter and linter for TOML files
+  - repo: https://github.com/ComPWA/taplo-pre-commit
+    rev: v0.9.3
+    hooks:
+      - id: taplo-format
+      - id: taplo-lint
+
+  # YAML files
+  - repo: https://github.com/lyz-code/yamlfix
+    rev: 1.17.0
+    hooks:
+      - id: yamlfix
+
+  # ===============================================
+  # Python Hooks
+  # ===============================================
+  # Ruff for linting and formatting
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.0
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-zero]  # Apply fixes, and exit with 0 even if files were modified
+        exclude: ^src/a2a/grpc/
+      - id: ruff-format
+        exclude: ^src/a2a/grpc/
+
+  # Keep uv.lock in sync
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.7.13
+    hooks:
+      - id: uv-lock
+
+  # Commitzen for conventional commit messages
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v4.8.3
+    hooks:
+      - id: commitizen
+        stages: [commit-msg]
+
+  # Gitleaks
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.27.2
+    hooks:
+      - id: gitleaks
diff --git a/.python-version b/.python-version
index 24ee5b1be..c8cfe3959 100644
--- a/.python-version
+++ b/.python-version
@@ -1 +1 @@
-3.13
+3.10
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 000000000..96f1cd949
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,3 @@
+{
+  ".": "1.3.0"
+}
diff --git a/.ruff.toml b/.ruff.toml
deleted file mode 100644
index f4baf4374..000000000
--- a/.ruff.toml
+++ /dev/null
@@ -1,128 +0,0 @@
-#################################################################################
-#
-# Ruff linter and code formatter for A2A
-#
-# This file follows the standards in Google Python Style Guide
-# https://google.github.io/styleguide/pyguide.html
-#  
-
-line-length = 80 # Google Style Guide §3.2: 80 columns
-indent-width = 4 # Google Style Guide §3.4: 4 spaces
-
-target-version = "py310" # Minimum Python version
-
-[lint]
-ignore = [
-    "COM812",
-    "FBT001",
-    "FBT002",
-    "D203",
-    "D213",
-    "ANN001",
-    "ANN201",
-    "ANN204",
-    "D100", # Ignore Missing docstring in public module (often desired at top level __init__.py)
-    "D102", # Ignore return type annotation in public method
-    "D104", # Ignore Missing docstring in public package (often desired at top level __init__.py)
-    "D107", # Ignore Missing docstring in __init__ (use class docstring)
-    "TD002", # Ignore Missing author in TODOs (often not required)
-    "TD003", # Ignore Missing issue link in TODOs (often not required/available)
-    "T201", # Ignore print presence
-    "RUF012", # Ignore Mutable class attributes should be annotated with `typing.ClassVar`
-    "RUF013", # Ignore implicit optional
-]
-
-select = [
-    "E",  # pycodestyle errors (PEP 8)
-    "W",  # pycodestyle warnings (PEP 8)
-    "F",  # Pyflakes (logical errors, unused imports/variables)
-    "I",  # isort (import sorting - Google Style §3.1.2)
-    "D",  # pydocstyle (docstring conventions - Google Style §3.8)
-    "N",  # pep8-naming (naming conventions - Google Style §3.16)
-    "UP", # pyupgrade (use modern Python syntax)
-    "ANN",# flake8-annotations (type hint usage/style - Google Style §2.22)
-    "A",  # flake8-builtins (avoid shadowing builtins)
-    "B",  # flake8-bugbear (potential logic errors & style issues - incl. mutable defaults B006, B008)
-    "C4", # flake8-comprehensions (unnecessary list/set/dict comprehensions)
-    "ISC",# flake8-implicit-str-concat (disallow implicit string concatenation across lines)
-    "T20",# flake8-print (discourage `print` - prefer logging)
-    "SIM",# flake8-simplify (simplify code, e.g., `if cond: return True else: return False`)
-    "PTH",# flake8-use-pathlib (use pathlib instead of os.path where possible)
-    "PL", # Pylint rules ported to Ruff (PLC, PLE, PLR, PLW)
-    "PIE",# flake8-pie (misc code improvements, e.g., no-unnecessary-pass)
-    "RUF",# Ruff-specific rules (e.g., RUF001-003 ambiguous unicode)
-    "RET",# flake8-return (consistency in return statements)
-    "SLF",# flake8-self (check for private member access via `self`)
-    "TID",# flake8-tidy-imports (relative imports, banned imports - configure if needed)
-    "YTT",# flake8-boolean-trap (checks for boolean positional arguments, truthiness tests - Google Style §3.10)
-    "TD", # flake8-todos (check TODO format - Google Style §3.7)
-]
-
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".pytype",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
-    "*/migrations/*",
-    "test_*",
-]
-
-[lint.isort]
-#force-sort-within-sections = true
-#combine-as-imports = true
-case-sensitive = true
-#force-single-line = false
-#known-first-party = []
-#known-third-party = []
-lines-after-imports = 2
-lines-between-types = 1
-#no-lines-before = ["LOCALFOLDER"]
-#required-imports = []
-#section-order = ["future", "standard-library", "third-party", "first-party", "local-folder"]
-
-[lint.pydocstyle]
-convention = "google"
-
-[lint.flake8-annotations]
-mypy-init-return = true
-allow-star-arg-any = true
-
-[lint.pep8-naming]
-ignore-names = ["test_*", "setUp", "tearDown", "mock_*"]
-classmethod-decorators = ["classmethod", "pydantic.validator", "pydantic.root_validator"]
-staticmethod-decorators = ["staticmethod"]
-
-[lint.flake8-tidy-imports]
-ban-relative-imports = "all" # Google generally prefers absolute imports (§3.1.2)
-
-[lint.flake8-quotes]
-docstring-quotes = "double"
-inline-quotes = "single"
-
-[lint.per-file-ignores]
-"__init__.py" = ["F401"]  # Ignore unused imports in __init__.py
-"*_test.py" = ["D", "ANN"]  # Ignore docstring and annotation issues in test files
-"test_*.py" = ["D", "ANN"]  # Ignore docstring and annotation issues in test files
-"types.py" = ["D", "E501", "N815"]  # Ignore docstring and annotation issues in types.py
-
-[format]
-docstring-code-format = true
-docstring-code-line-length = "dynamic" # Or set to 80
-quote-style = "single"
-indent-style = "space"
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 000000000..aec9d68e2
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,6 @@
+{
+  "recommendations": [
+    "charliermarsh.ruff"
+  ],
+  "unwantedRecommendations": []
+}
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 376512389..5c19f4812 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -12,7 +12,12 @@
         "PYTHONPATH": "${workspaceFolder}"
       },
       "cwd": "${workspaceFolder}/examples/helloworld",
-      "args": ["--host", "localhost", "--port", "9999"]
+      "args": [
+        "--host",
+        "localhost",
+        "--port",
+        "9999"
+      ]
     },
     {
       "name": "Debug Currency Agent",
@@ -25,7 +30,25 @@
         "PYTHONPATH": "${workspaceFolder}"
       },
       "cwd": "${workspaceFolder}/examples/langgraph",
-      "args": ["--host", "localhost", "--port", "10000"]
+      "args": [
+        "--host",
+        "localhost",
+        "--port",
+        "10000"
+      ]
+    },
+    {
+      "name": "Pytest All",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "args": [
+        "-v",
+        "-s"
+      ],
+      "console": "integratedTerminal",
+      "justMyCode": true,
+      "python": "${workspaceFolder}/.venv/bin/python",
     }
   ]
 }
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 3ffee4e75..0f968e252 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,7 @@
 {
-  "python.testing.pytestArgs": ["tests"],
+  "python.testing.pytestArgs": [
+    "tests"
+  ],
   "python.testing.unittestEnabled": false,
   "python.testing.pytestEnabled": true,
   "editor.formatOnSave": true,
@@ -7,8 +9,15 @@
     "editor.defaultFormatter": "charliermarsh.ruff",
     "editor.formatOnSave": true,
     "editor.codeActionsOnSave": {
-      "source.organizeImports": "always"
+      "source.organizeImports": "always",
+      "source.fixAll.ruff": "explicit"
     }
   },
-  "ruff.importStrategy": "fromEnvironment"
+  "ruff.importStrategy": "fromEnvironment",
+  "files.insertFinalNewline": true,
+  "files.trimFinalNewlines": false,
+  "files.trimTrailingWhitespace": false,
+  "editor.rulers": [
+    80
+  ]
 }
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 000000000..a4fbea5b2
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,44 @@
+# AGENTS.md
+
+Python SDK for the [Agent2Agent (A2A) Protocol](https://a2a-protocol.org/latest/specification/)
+(`a2a` module, `a2a-sdk` distribution).  It handles complex messaging, task management,
+and communication across different transports (REST, gRPC, JSON-RPC).
+
+## Technology Stack & Architecture
+
+- **Language**: Python 3.10+
+- **Package Manager**: `uv`
+- **Lead Transports**: Starlette (REST/JSON-RPC), gRPC
+- **Data Layer**: SQLAlchemy (SQL), Pydantic (Logic/Legacy), Protobuf (Modern Messaging)
+- **Key Directories**:
+    - `/src`: Core implementation logic.
+    - `/tests`: Comprehensive test suite.
+    - `/docs`: AI guides and migration documentation.
+
+## Mandatory workflow
+
+You MUST do all of the following:
+
+1. **At the start of every task that touches files**, read
+   `docs/ai/coding_conventions.md`, `docs/ai/mandatory_checks.md`,
+   and `docs/ai/evidence_rules.md`.
+2. **Before declaring any task done**, run the full check sequence
+   in `docs/ai/mandatory_checks.md` — including for
+   markdown/comment/whitespace-only changes.
+3. **On any mistake**, load the `mistake-reflection` skill at
+   `.agents/skills/mistake-reflection/SKILL.md` **before** continuing
+   your response. The skill appends a structured entry to
+   `docs/ai/ai_learnings.md` (gitignored local journal) so the user
+   can use those findings to improve the workflow.
+
+   When unsure: load the skill. False positives are free; false
+   negatives are how the same mistake recurs.
+
+
+## Optional extras
+
+`pyproject.toml` defines extras (`grpc`, `telemetry`, `postgresql`,
+etc.). The dev group installs `a2a-sdk[all]`, so anything gated behind
+an extra must still **import lazily** at runtime — the install-smoke
+harness verifies this per profile.
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 000000000..0231ad547
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,993 @@
+# Changelog
+
+## [1.3.0](https://github.com/a2aproject/a2a-python/compare/v1.2.3...v1.3.0) (2026-10-27)
+
+
+### Features
+
+* **server:** release parked interrupted tasks after a configurable timeout ([#1338](https://github.com/a2aproject/a2a-python/issues/1338)) ([b22a68d](https://github.com/a2aproject/a2a-python/commit/b22a68d242c32edddaa8953d0040ca82897e0b9b))
+
+
+### Bug Fixes
+
+* **client:** Create separate httpx per client when none configured ([#1358](https://github.com/a2aproject/a2a-python/issues/1358)) ([d316d0e](https://github.com/a2aproject/a2a-python/commit/d316d0e85e4d229df261d0cee0e9d9c0e5263207))
+* **client:** raise A2A errors for malformed JSON-RPC responses ([#1375](https://github.com/a2aproject/a2a-python/issues/1375)) ([7e55413](https://github.com/a2aproject/a2a-python/commit/7e554137514b693cc952e6544a9eaf36c7d56643))
+* **client:** rejections from unrecognized fields ([#1354](https://github.com/a2aproject/a2a-python/issues/1354)) ([91929cd](https://github.com/a2aproject/a2a-python/commit/91929cda989caba089584ceafa7796583f25bec4))
+* **compat:** keep an unset v0.3 status message and provider as None ([#1362](https://github.com/a2aproject/a2a-python/issues/1362)) ([cdb4799](https://github.com/a2aproject/a2a-python/commit/cdb479957e81600f68f946f8ff0122667673cb35)), closes [#1361](https://github.com/a2aproject/a2a-python/issues/1361)
+* **compat:** return A2A error codes from the v0.3 JSON-RPC adapter ([#1369](https://github.com/a2aproject/a2a-python/issues/1369)) ([8e32d53](https://github.com/a2aproject/a2a-python/commit/8e32d53173f8924beb7df0d3210e28a9fe9020f9))
+* **compat:** set last_updated when storing a task in v0.3 format ([#1372](https://github.com/a2aproject/a2a-python/issues/1372)) ([30b6d50](https://github.com/a2aproject/a2a-python/commit/30b6d5067a9256447e3d5324163b091fc4bbad74)), closes [#1371](https://github.com/a2aproject/a2a-python/issues/1371)
+* **core:** restore structured __repr__ on A2A exceptions ([#1348](https://github.com/a2aproject/a2a-python/issues/1348)) ([79a6f45](https://github.com/a2aproject/a2a-python/commit/79a6f451f49fdeaec099d723542363b5bc6dead7))
+* **server:** allow recovery after status event validation fails ([#1365](https://github.com/a2aproject/a2a-python/issues/1365)) ([ca3ef0d](https://github.com/a2aproject/a2a-python/commit/ca3ef0d6c63384228db88d4984536a8189831d08))
+* **server:** apply history_length to legacy streaming sends ([#1364](https://github.com/a2aproject/a2a-python/issues/1364)) ([261c074](https://github.com/a2aproject/a2a-python/commit/261c074aa4de522dfa609882666c98c5bd1a52d0))
+* **server:** include legacy task states in database list filters ([#1337](https://github.com/a2aproject/a2a-python/issues/1337)) ([e12d494](https://github.com/a2aproject/a2a-python/commit/e12d494b4136351d5b5d07b5c6beae95a500fc4e))
+* **server:** record executor failures through the event consumer ([#1366](https://github.com/a2aproject/a2a-python/issues/1366)) ([ad85806](https://github.com/a2aproject/a2a-python/commit/ad85806d9e43249eef5e3ad9724b0a5540cf99fb))
+* **server:** reject boolean JSON-RPC request IDs ([#1350](https://github.com/a2aproject/a2a-python/issues/1350)) ([05392b3](https://github.com/a2aproject/a2a-python/commit/05392b373f70fea18349b8c66bfffb669b3b1137))
+* skip malformed agent card signature headers ([#1335](https://github.com/a2aproject/a2a-python/issues/1335)) ([b21a144](https://github.com/a2aproject/a2a-python/commit/b21a1445c8e3a4dcd9edfa1d23e7e6af8382d8b7))
+
+
+### Documentation
+
+* **helpers:** note that whole numbers in a data Part come back as floats ([#1373](https://github.com/a2aproject/a2a-python/issues/1373)) ([654774f](https://github.com/a2aproject/a2a-python/commit/654774f3d43b471e17fc2c6901998c71015ec450))
+
+
+### Miscellaneous Chores
+
+* release 1.3.0 ([#1389](https://github.com/a2aproject/a2a-python/issues/1389)) ([fb6373f](https://github.com/a2aproject/a2a-python/commit/fb6373f2e4bad3c9e6130325dd2ba092749f8998))
+
+## [1.2.3](https://github.com/a2aproject/a2a-python/compare/v1.2.2...v1.2.3) (2026-10-17)
+
+
+### Bug Fixes
+
+* **client:** ignore the patch version when preferring a 1.0 interface ([#1304](https://github.com/a2aproject/a2a-python/issues/1304)) ([cbb2d84](https://github.com/a2aproject/a2a-python/commit/cbb2d8418df26567b4ed4ed9e160071dd04904d8))
+* **client:** normalize malformed agent card parsing errors ([#1307](https://github.com/a2aproject/a2a-python/issues/1307)) ([486f0f6](https://github.com/a2aproject/a2a-python/commit/486f0f65b753077f401f2428490e26ca0eedc092))
+* **compat:** block on a v0.3 gRPC and REST send without configuration ([#1334](https://github.com/a2aproject/a2a-python/issues/1334)) ([8160310](https://github.com/a2aproject/a2a-python/commit/8160310dd36e55ae33879d95692e2535e1cfdab8)), closes [#1321](https://github.com/a2aproject/a2a-python/issues/1321)
+* **compat:** treat a v0.3 history_length of 0 as unlimited in JSON-RPC and REST ([#1312](https://github.com/a2aproject/a2a-python/issues/1312)) ([e86695c](https://github.com/a2aproject/a2a-python/commit/e86695cb2076874950f36f53d49771c8e09e185e))
+* **jcs:** count open containers for the nesting bound, so an empty container leaf is refused ([#1294](https://github.com/a2aproject/a2a-python/issues/1294)) ([5653daf](https://github.com/a2aproject/a2a-python/commit/5653daf8315ab58c8dacc53be720c4ed632ee7ce))
+* **server:** isolate push notification failures from the task lifecycle ([#1329](https://github.com/a2aproject/a2a-python/issues/1329)) ([0ee47d7](https://github.com/a2aproject/a2a-python/commit/0ee47d7baa47a706e33934a4e4c3d46bad16298f))
+* **server:** mark internal lifecycle events done so a cancelled stream frees its producer ([#1336](https://github.com/a2aproject/a2a-python/issues/1336)) ([a4c4fc9](https://github.com/a2aproject/a2a-python/commit/a4c4fc91a22778f3d805e5e592bf690915a33033))
+* **server:** reject push URLs in shared address space ([#1326](https://github.com/a2aproject/a2a-python/issues/1326)) ([01da00b](https://github.com/a2aproject/a2a-python/commit/01da00b0951ba6201af860d17b4c088be7902d43))
+* **server:** release the ActiveTask after a direct Message response ([#1297](https://github.com/a2aproject/a2a-python/issues/1297)) ([49ebce6](https://github.com/a2aproject/a2a-python/commit/49ebce66389171dce38b74ebefb31ae4ad042e7e))
+* **server:** run follow-up messages in the sender's contextvars ([#1317](https://github.com/a2aproject/a2a-python/issues/1317)) ([a016002](https://github.com/a2aproject/a2a-python/commit/a0160025d6d211b0be1762cb829e7a47c147191a))
+* **server:** warn when an AgentCard is missing required fields ([#1279](https://github.com/a2aproject/a2a-python/issues/1279)) ([4f4101c](https://github.com/a2aproject/a2a-python/commit/4f4101cefd5e636a932c8017a8b3b11634be1d67))
+* **telemetry:** let trace_function alone decide a span's status ([#1309](https://github.com/a2aproject/a2a-python/issues/1309)) ([59dcbfb](https://github.com/a2aproject/a2a-python/commit/59dcbfb16f73c7c596e6d60cb700ed71193c5cce))
+
+## [1.2.2](https://github.com/a2aproject/a2a-python/compare/v1.2.1...v1.2.2) (2026-10-03)
+
+
+### Features
+
+* allow configuring SSE shutdown grace periods ([#1222](https://github.com/a2aproject/a2a-python/issues/1222)) ([6ff0a82](https://github.com/a2aproject/a2a-python/commit/6ff0a826b49a1814d05b6bb11e546d0fa3407c4c))
+
+
+### Bug Fixes
+
+* **client:** handle REST error bodies that are not a google.rpc.Status ([#1300](https://github.com/a2aproject/a2a-python/issues/1300)) ([ee61dc1](https://github.com/a2aproject/a2a-python/commit/ee61dc1328eed71d4fde53d26540bcdf3ab6ef91))
+* **compat:** keep timestamp and three other fields in v0.3 gRPC conversion ([#1277](https://github.com/a2aproject/a2a-python/issues/1277)) ([fad0482](https://github.com/a2aproject/a2a-python/commit/fad04821ca9ca70f5378305c2f3ce9225d323e72)), closes [#1276](https://github.com/a2aproject/a2a-python/issues/1276)
+* **compat:** treat an unset v0.3 history_length as unlimited ([#1306](https://github.com/a2aproject/a2a-python/issues/1306)) ([21fe836](https://github.com/a2aproject/a2a-python/commit/21fe836484f959f7d7c2541866f99a07b370211a)), closes [#1305](https://github.com/a2aproject/a2a-python/issues/1305)
+* **server:** name the task state in terminal-state errors ([#1302](https://github.com/a2aproject/a2a-python/issues/1302)) ([fdca1d0](https://github.com/a2aproject/a2a-python/commit/fdca1d0f9ee75a4e136c199da3ee1757764cd3dd))
+* **server:** return the stored id when creating a push notification config ([#1236](https://github.com/a2aproject/a2a-python/issues/1236)) ([dac7d9d](https://github.com/a2aproject/a2a-python/commit/dac7d9d4d01a56b1c9aad83b069326fbf8f114e8)), closes [#1237](https://github.com/a2aproject/a2a-python/issues/1237)
+* **server:** stop printing a traceback to stderr for malformed JSON-RPC bodies ([#1301](https://github.com/a2aproject/a2a-python/issues/1301)) ([5a1a004](https://github.com/a2aproject/a2a-python/commit/5a1a004ecd9e3051223923f7e2db8c15401a20f7))
+
+## [1.2.1](https://github.com/a2aproject/a2a-python/compare/v1.2.0...v1.2.1) (2026-09-30)
+
+
+### Bug Fixes
+
+* **server:** use keyset cursors for ListTasks page tokens ([#1282](https://github.com/a2aproject/a2a-python/issues/1282)) ([b7cba7c](https://github.com/a2aproject/a2a-python/commit/b7cba7c905bc1872d5591f0ce439afc02a3d9eed)), closes [#1280](https://github.com/a2aproject/a2a-python/issues/1280)
+
+## [1.2.0](https://github.com/a2aproject/a2a-python/compare/v1.1.5...v1.2.0) (2026-09-29)
+
+
+### Features
+
+* **rest:** serve HTTP+JSON responses as application/a2a+json ([#1274](https://github.com/a2aproject/a2a-python/issues/1274)) ([dc5a5da](https://github.com/a2aproject/a2a-python/commit/dc5a5da79e2063c9a309dcc44dcc021f656d4c77))
+* **server:** add caching headers to the agent card endpoint ([#1272](https://github.com/a2aproject/a2a-python/issues/1272)) ([83d7f5d](https://github.com/a2aproject/a2a-python/commit/83d7f5d55f06b153809c611511e64f2a842504fa))
+* **server:** add multi-replica cluster mode ([#1281](https://github.com/a2aproject/a2a-python/issues/1281)) ([942d621](https://github.com/a2aproject/a2a-python/commit/942d6215bdcc4a3ea8871c26effe83c7eed6910f))
+* **server:** add opt-in validation of message media types against the agent card ([#1269](https://github.com/a2aproject/a2a-python/issues/1269)) ([8037b24](https://github.com/a2aproject/a2a-python/commit/8037b246192225734b9ad9e56163fc4b49f40d2b))
+
+
+### Bug Fixes
+
+* compare in-memory task timestamps numerically ([#1233](https://github.com/a2aproject/a2a-python/issues/1233)) ([0d5473c](https://github.com/a2aproject/a2a-python/commit/0d5473ca4fa6d40034a6a7c8d65bce5cd85d8167))
+* **server:** ignore unrecognized request fields and fix parse-error data shape ([#1273](https://github.com/a2aproject/a2a-python/issues/1273)) ([83f1cf8](https://github.com/a2aproject/a2a-python/commit/83f1cf88219e3a13157c498e8baea9d64705630e))
+* **server:** reject a message whose contextId disagrees with its task ([#1270](https://github.com/a2aproject/a2a-python/issues/1270)) ([c25022f](https://github.com/a2aproject/a2a-python/commit/c25022ff0f0832ea82d6873051665f7dd46626c6))
+* **server:** reject terminal-task operations with UnsupportedOperationError ([#1268](https://github.com/a2aproject/a2a-python/issues/1268)) ([6cce91b](https://github.com/a2aproject/a2a-python/commit/6cce91beb57da1d6337a90dfbb75e21004f57fd1))
+* **server:** send PushNotificationConfig.authentication as an Authorization header ([#1271](https://github.com/a2aproject/a2a-python/issues/1271)) ([5751d31](https://github.com/a2aproject/a2a-python/commit/5751d313a99ba62186626228f9ec92b914f1f014)), closes [#585](https://github.com/a2aproject/a2a-python/issues/585)
+
+
+### Documentation
+
+* **samples:** add Agent Card signing sample ([#1198](https://github.com/a2aproject/a2a-python/issues/1198)) ([f3ac824](https://github.com/a2aproject/a2a-python/commit/f3ac82489dd84ce9dcd3802357cb4e987ffdbb74))
+
+## [1.1.5](https://github.com/a2aproject/a2a-python/compare/v1.1.4...v1.1.5) (2026-09-21)
+
+
+### Bug Fixes
+
+* **deps:** support protobuf 7 ([#1260](https://github.com/a2aproject/a2a-python/issues/1260)) ([67ba0a4](https://github.com/a2aproject/a2a-python/commit/67ba0a41d4f5bc4cfef3db4073c3b981888f7efd))
+* replace deprecated FieldDescriptor.label with is_repeated in proto_utils ([#1158](https://github.com/a2aproject/a2a-python/issues/1158)) ([4554e2d](https://github.com/a2aproject/a2a-python/commit/4554e2d6279b560bfcf61050799c6ea66da17583))
+* **server:** avoid out-of-range datetime task ordering ([#1220](https://github.com/a2aproject/a2a-python/issues/1220)) ([d55a3d3](https://github.com/a2aproject/a2a-python/commit/d55a3d323733ddf416d98d7d702d0bd73e22a3e4))
+
+## [1.1.4](https://github.com/a2aproject/a2a-python/compare/v1.1.3...v1.1.4) (2026-09-07)
+
+
+### Features
+
+* **itk:** register itk-python-v10-agent as a uv workspace member and update dependency version markers ([#1203](https://github.com/a2aproject/a2a-python/issues/1203)) ([6eee895](https://github.com/a2aproject/a2a-python/commit/6eee8956fa0e3d6378e4a61b52cf674d05b81229))
+* **itk:** use shared scenarios ([#1201](https://github.com/a2aproject/a2a-python/issues/1201)) ([b4a0b21](https://github.com/a2aproject/a2a-python/commit/b4a0b212df4bbe44bc1d41a6165037f77dd7a993))
+
+
+### Bug Fixes
+
+* make event queue sink removal idempotent ([#1134](https://github.com/a2aproject/a2a-python/issues/1134)) ([58c72c6](https://github.com/a2aproject/a2a-python/commit/58c72c646deab1ff3a1d239bda52a09a48f3a821))
+* omit artifacts from list tasks responses ([#1212](https://github.com/a2aproject/a2a-python/issues/1212)) ([35ef52e](https://github.com/a2aproject/a2a-python/commit/35ef52e8b0dcba8a85f5f12bd8e5b9aa21354d79))
+* owner-scope cancel/subscribe and write terminal state on cancel ([#1159](https://github.com/a2aproject/a2a-python/issues/1159), [#1170](https://github.com/a2aproject/a2a-python/issues/1170)) ([#1172](https://github.com/a2aproject/a2a-python/issues/1172)) ([ddbf853](https://github.com/a2aproject/a2a-python/commit/ddbf853d692ea207dad2be610e675298e0365511))
+* prevent first-owner write loss in in-memory stores ([#1194](https://github.com/a2aproject/a2a-python/issues/1194)) ([bcc489c](https://github.com/a2aproject/a2a-python/commit/bcc489c4f19f0fd5898cc8c4dac0ef54ae7b4de7))
+* **server:** let subscriber taps evict on full instead of wedging dispatch ([#1137](https://github.com/a2aproject/a2a-python/issues/1137)) ([0c2126f](https://github.com/a2aproject/a2a-python/commit/0c2126fbf1e2b418872181ce2ae200f972b4c202))
+* **server:** surface producer errors after failed tasks ([#1229](https://github.com/a2aproject/a2a-python/issues/1229)) ([bc32d7e](https://github.com/a2aproject/a2a-python/commit/bc32d7e5a94976ffb3c3e5ed706457bea530da4f))
+* **server:** validate push-notification URLs at config creation ([#1173](https://github.com/a2aproject/a2a-python/issues/1173)) ([3eb88e2](https://github.com/a2aproject/a2a-python/commit/3eb88e223e62ec510128a8fb51e3ccfe7aa6d596))
+* **server:** validate push-notification URLs before dispatch (SSRF hardening) ([#1164](https://github.com/a2aproject/a2a-python/issues/1164)) ([57a9df3](https://github.com/a2aproject/a2a-python/commit/57a9df3e2bd79a4b6d889e17511f789baa038dac))
+* **server:** warn when queue_manager is ignored in DefaultRequestHandlerV2 ([#1153](https://github.com/a2aproject/a2a-python/issues/1153)) ([08fd223](https://github.com/a2aproject/a2a-python/commit/08fd223882749a90c498ce835de9ac136eca375e))
+
+
+### Documentation
+
+* **server:** say what the evict-on-full check actually tests ([#1209](https://github.com/a2aproject/a2a-python/issues/1209)) ([4b7b242](https://github.com/a2aproject/a2a-python/commit/4b7b24293c55518e3f8b815b04fadf77ed488505))
+
+## [1.1.3](https://github.com/a2aproject/a2a-python/compare/v1.1.2...v1.1.3) (2026-08-18)
+
+
+### Bug Fixes
+
+* use threading.RLock for in-memory server singletons ([#1162](https://github.com/a2aproject/a2a-python/issues/1162)) ([5bae35b](https://github.com/a2aproject/a2a-python/commit/5bae35b79d672aac4160dbf25dd05ed108e12419))
+
+## [1.1.2](https://github.com/a2aproject/a2a-python/compare/v1.1.1...v1.1.2) (2026-07-20)
+
+
+### Features
+
+* **server:** add aclose() to drain ActiveTask background tasks ([#1101](https://github.com/a2aproject/a2a-python/issues/1101)) ([#1105](https://github.com/a2aproject/a2a-python/issues/1105)) ([9801f46](https://github.com/a2aproject/a2a-python/commit/9801f4637fc0689b461dd3db00968bec496cd7ac))
+
+
+### Bug Fixes
+
+* **agent_execution:** resolve ActiveTask 'destroyed but pending' warning during teardown ([#1122](https://github.com/a2aproject/a2a-python/issues/1122)) ([d19c4d2](https://github.com/a2aproject/a2a-python/commit/d19c4d260e375d52175eec4bbd9018edb3eb270b))
+* persist early producer failure as FAILED with originating message ([#1106](https://github.com/a2aproject/a2a-python/issues/1106)) ([4e3d724](https://github.com/a2aproject/a2a-python/commit/4e3d7249e2316859fe8e9b85fd688d6d4525d690))
+
+## [1.1.1](https://github.com/a2aproject/a2a-python/compare/v1.1.0...v1.1.1) (2026-07-15)
+
+
+### Bug Fixes
+
+* **server:** improve Swagger /docs example annotations for A2A routes ([#1092](https://github.com/a2aproject/a2a-python/issues/1092)) ([46b292b](https://github.com/a2aproject/a2a-python/commit/46b292b433a5df5a9721d6227cb53753f2978437))
+
+### Miscellaneous Chores
+
+* **grpc:** eliminate third-party grpcio-status dependency ([#1130](https://github.com/a2aproject/a2a-python/issues/1130)) ([723880e](https://github.com/a2aproject/a2a-python/commit/723880e679310a249a287657476852a0fa30ba95))
+* **http:** eliminate httpx-sse dependency ([#1132](https://github.com/a2aproject/a2a-python/issues/1132)) ([0d82ab9](https://github.com/a2aproject/a2a-python/commit/0d82ab985ffbac381a38adb5bd160674fa05eb18))
+
+## [1.1.0](https://github.com/a2aproject/a2a-python/compare/v1.0.3...v1.1.0) (2026-05-29)
+
+
+### Features
+
+* **server:** restore FastAPI /docs visibility for A2A routes ([#1024](https://github.com/a2aproject/a2a-python/issues/1024)) ([1122d4e](https://github.com/a2aproject/a2a-python/commit/1122d4e92e49f6eaadb5dbd94c67352adb13bf44))
+
+
+### Bug Fixes
+
+* **compat:** remove ListTasks from v0.3 REST adapter ([#1043](https://github.com/a2aproject/a2a-python/issues/1043)) ([#1068](https://github.com/a2aproject/a2a-python/issues/1068)) ([5c88793](https://github.com/a2aproject/a2a-python/commit/5c8879341a3ee7d14b1875a9131101bf9a234522))
+* properly convert metadata to dict in `RequestContext.metadata` ([#1081](https://github.com/a2aproject/a2a-python/issues/1081)) ([d2f2e18](https://github.com/a2aproject/a2a-python/commit/d2f2e18702dd6940ecec020cddd76161174574c1))
+* raise on append=True for unknown artifact_id ([#1038](https://github.com/a2aproject/a2a-python/issues/1038)) ([#1077](https://github.com/a2aproject/a2a-python/issues/1077)) ([fe1f24b](https://github.com/a2aproject/a2a-python/commit/fe1f24b3de8b7ca7941bde35c9eb4a423fda72c0))
+* release reference count on non-terminal exit to prevent stale registry entries ([#1079](https://github.com/a2aproject/a2a-python/issues/1079)) ([501255c](https://github.com/a2aproject/a2a-python/commit/501255c467c998867de92e9928ee64d0d2cf9145))
+* **server:** preserve non-ASCII characters in streaming JSON responses ([#1080](https://github.com/a2aproject/a2a-python/issues/1080)) ([d46c6f9](https://github.com/a2aproject/a2a-python/commit/d46c6f94bd26c898f6092e0ec97c2a19cbaa2853))
+* **telemetry:** don't mark QueueShutDown as an error span ([#1075](https://github.com/a2aproject/a2a-python/issues/1075)) ([54a485c](https://github.com/a2aproject/a2a-python/commit/54a485ccb709f5caab2e477f1c44acd3bee0a890))
+
+
+### Documentation
+
+* clarify `EventQueue` usage ([#1066](https://github.com/a2aproject/a2a-python/issues/1066)) ([11dd68a](https://github.com/a2aproject/a2a-python/commit/11dd68ad4745fc320470e81e4b7029ccdbf6fc84))
+
+
+### Miscellaneous Chores
+
+* release 1.1.0 ([#1088](https://github.com/a2aproject/a2a-python/issues/1088)) ([3058a33](https://github.com/a2aproject/a2a-python/commit/3058a33eb98b7c06b79ee3ce599e9e58f2b744bd))
+
+## [1.0.3](https://github.com/a2aproject/a2a-python/compare/v1.0.2...v1.0.3) (2026-05-13)
+
+
+### Features
+
+* **helpers:** add non-text Part extractors and artifact update events ([745d998](https://github.com/a2aproject/a2a-python/commit/745d9988beca9b708e24349ec9dfa4138f12d472))
+
+
+### Bug Fixes
+
+* **deps:** cap protobuf below 7 ([#1019](https://github.com/a2aproject/a2a-python/issues/1019)) ([7af6050](https://github.com/a2aproject/a2a-python/commit/7af60502532a44f440885157aaae36c024416b85))
+* **errors:** align error mappings with A2A spec  ([#1055](https://github.com/a2aproject/a2a-python/issues/1055)) ([4e01a91](https://github.com/a2aproject/a2a-python/commit/4e01a914330b29de110d93f4e5adcbb9ecc49e78))
+* **errors:** emit JSON-RPC error.data as typed-details array per A2A 1.0 spec hot-fix ([#1058](https://github.com/a2aproject/a2a-python/issues/1058)) ([3ce65c5](https://github.com/a2aproject/a2a-python/commit/3ce65c533ab5966cfa0409d7ab18e01c6c0c4d03))
+* Improve task_push_notification_config presence check. ([#1047](https://github.com/a2aproject/a2a-python/issues/1047)) ([94ad594](https://github.com/a2aproject/a2a-python/commit/94ad59435649a6bd56efd2d260bf5193d7e991b4))
+
+
+### Documentation
+
+* high level active task architecture documentation ([#1056](https://github.com/a2aproject/a2a-python/issues/1056)) ([09a2221](https://github.com/a2aproject/a2a-python/commit/09a22212cf7c7a9669f2b4a184157d7a0a252ac9))
+
+## [1.0.2](https://github.com/a2aproject/a2a-python/compare/v1.0.1...v1.0.2) (2026-04-24)
+
+
+### Features
+
+* **helpers:** add non-text Part, Message, and Artifact helpers ([#1004](https://github.com/a2aproject/a2a-python/issues/1004)) ([cfdbe4c](https://github.com/a2aproject/a2a-python/commit/cfdbe4c08c58b773a8766c17f5b5eabbe67bf3dd))
+
+
+### Bug Fixes
+
+* **proto:** use field.label instead of is_repeated for protobuf compatibility ([#1010](https://github.com/a2aproject/a2a-python/issues/1010)) ([7d197db](https://github.com/a2aproject/a2a-python/commit/7d197dbf81e31398a41f8d6795e15170f082104f))
+* **server:** deliver push notifications across all owners ([#1016](https://github.com/a2aproject/a2a-python/issues/1016)) ([c24ae05](https://github.com/a2aproject/a2a-python/commit/c24ae055715ba69329ffa4e36489379308cd0bde))
+
+## [1.0.1](https://github.com/a2aproject/a2a-python/compare/v1.0.0...v1.0.1) (2026-04-22)
+
+
+### Bug Fixes
+
+* **compat:** avoid unconditional grpc import in v0.3 context builders ([#1006](https://github.com/a2aproject/a2a-python/issues/1006)) ([6b46ceb](https://github.com/a2aproject/a2a-python/commit/6b46ceb3e036290ea2b0764b1697f2901ad2df08))
+
+## [1.0.0](https://github.com/a2aproject/a2a-python/compare/v1.0.0-alpha.3...v1.0.0) (2026-04-20)
+
+See the [**v0.3 → v1.0 migration guide**](docs/migrations/v1_0/README.md) and changelog entries for alpha versions below.
+
+### ⚠ BREAKING CHANGES
+
+* remove Vertex AI Task Store integration ([#999](https://github.com/a2aproject/a2a-python/issues/999))
+
+### Bug Fixes
+
+* rely on agent executor implementation for stream termination ([#988](https://github.com/a2aproject/a2a-python/issues/988)) ([d77cd68](https://github.com/a2aproject/a2a-python/commit/d77cd68f5e69b0ffccaca5e3deab4c1a397cfe9c))
+
+
+### Documentation
+
+* add comprehensive v0.3 to v1.0 migration guide ([#987](https://github.com/a2aproject/a2a-python/issues/987)) ([10dea8b](https://github.com/a2aproject/a2a-python/commit/10dea8b4448c5cb7d9e72d74677fd60880cc38df))
+
+
+### Miscellaneous Chores
+
+* release 1.0.0 ([530ec37](https://github.com/a2aproject/a2a-python/commit/530ec37f4c4580095c2411e40740ca0186fd1240))
+* remove Vertex AI Task Store integration ([#999](https://github.com/a2aproject/a2a-python/issues/999)) ([7fce2ad](https://github.com/a2aproject/a2a-python/commit/7fce2ada1eb331e230925993758e8c7663da9a13))
+
+## [1.0.0-alpha.3](https://github.com/a2aproject/a2a-python/compare/v1.0.0-alpha.2...v1.0.0-alpha.3) (2026-04-17)
+
+
+### Bug Fixes
+
+* update `with_a2a_extensions` to append instead of overwriting ([#985](https://github.com/a2aproject/a2a-python/issues/985)) ([e1d0e7a](https://github.com/a2aproject/a2a-python/commit/e1d0e7a72e2b9633be0b76c952f6c2e6fe11e3e5))
+
+## [1.0.0-alpha.2](https://github.com/a2aproject/a2a-python/compare/v1.0.0-alpha.1...v1.0.0-alpha.2) (2026-04-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* clean helpers and utils folders structure ([#983](https://github.com/a2aproject/a2a-python/issues/983))
+* Raise errors on invalid AgentExecutor behavior. ([#979](https://github.com/a2aproject/a2a-python/issues/979))
+* extract developer helpers in helpers folder ([#978](https://github.com/a2aproject/a2a-python/issues/978))
+
+### Features
+
+* Raise errors on invalid AgentExecutor behavior. ([#979](https://github.com/a2aproject/a2a-python/issues/979)) ([f4a0bcd](https://github.com/a2aproject/a2a-python/commit/f4a0bcdf68107c95e6c0a5e6696e4a7d6e01a03f))
+* **utils:** add `display_agent_card()` utility for human-readable AgentCard inspection ([#972](https://github.com/a2aproject/a2a-python/issues/972)) ([3468180](https://github.com/a2aproject/a2a-python/commit/3468180ac7396d453d99ce3e74cdd7f5a0afb5ab))
+
+
+### Bug Fixes
+
+* Don't generate empty metadata change events in VertexTaskStore ([#974](https://github.com/a2aproject/a2a-python/issues/974)) ([b58b03e](https://github.com/a2aproject/a2a-python/commit/b58b03ef58bd806db3accbe6dca8fc444a43bc18)), closes [#802](https://github.com/a2aproject/a2a-python/issues/802)
+* **extensions:** support both header names and remove "activation" concept ([#984](https://github.com/a2aproject/a2a-python/issues/984)) ([b8df210](https://github.com/a2aproject/a2a-python/commit/b8df210b00d0f249ca68f0d814191c4205e18b35))
+
+
+### Documentation
+
+* AgentExecutor interface documentation ([#976](https://github.com/a2aproject/a2a-python/issues/976)) ([d667e4f](https://github.com/a2aproject/a2a-python/commit/d667e4fa55e99225eb3c02e009b426a3bc2d449d))
+* move `ai_learnings.md` to local-only and update `GEMINI.md` ([#982](https://github.com/a2aproject/a2a-python/issues/982)) ([f6610fa](https://github.com/a2aproject/a2a-python/commit/f6610fa35e1f5fbc3e7e6cd9e29a5177a538eb4e))
+
+
+### Code Refactoring
+
+* clean helpers and utils folders structure ([#983](https://github.com/a2aproject/a2a-python/issues/983)) ([c87e87c](https://github.com/a2aproject/a2a-python/commit/c87e87c76c004c73c9d6b9bd8cacfd4e590598e6))
+* extract developer helpers in helpers folder ([#978](https://github.com/a2aproject/a2a-python/issues/978)) ([5f3ea29](https://github.com/a2aproject/a2a-python/commit/5f3ea292389cf72a25a7cf2792caceb4af45f6da))
+
+## [1.0.0-alpha.1](https://github.com/a2aproject/a2a-python/compare/v1.0.0-alpha.0...v1.0.0-alpha.1) (2026-04-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* **client:** make ClientConfig.push_notification_config singular ([#955](https://github.com/a2aproject/a2a-python/issues/955))
+* **client:** reorganize ClientFactory API ([#947](https://github.com/a2aproject/a2a-python/issues/947))
+* **server:** add build_user function to DefaultContextBuilder to allow A2A user creation customization ([#925](https://github.com/a2aproject/a2a-python/issues/925))
+* **client:** remove `ClientTaskManager` and `Consumers` from client ([#916](https://github.com/a2aproject/a2a-python/issues/916))
+* **server:** migrate from Application wrappers to Starlette route-based endpoints for rest ([#892](https://github.com/a2aproject/a2a-python/issues/892))
+* **server:** migrate from Application wrappers to Starlette route-based endpoints for jsonrpc ([#873](https://github.com/a2aproject/a2a-python/issues/873))
+
+### Features
+
+* A2A Version Header validation on server side. ([#865](https://github.com/a2aproject/a2a-python/issues/865)) ([b261ceb](https://github.com/a2aproject/a2a-python/commit/b261ceb98bf46cc1e479fcdace52fef8371c8e58))
+* Add GetExtendedAgentCard Support to RequestHandlers ([#919](https://github.com/a2aproject/a2a-python/issues/919)) ([2159140](https://github.com/a2aproject/a2a-python/commit/2159140b1c24fe556a41accf97a6af7f54ec6701))
+* Add support for more Task Message and Artifact fields in the Vertex Task Store ([#908](https://github.com/a2aproject/a2a-python/issues/908)) ([5e0dcd7](https://github.com/a2aproject/a2a-python/commit/5e0dcd798fcba16a8092b0b4c2d3d8026ca287de))
+* Add support for more Task Message and Artifact fields in the Vertex Task Store ([#936](https://github.com/a2aproject/a2a-python/issues/936)) ([605fa49](https://github.com/a2aproject/a2a-python/commit/605fa4913ad23539a51a3ee1f5b9ca07f24e1d2d))
+* Create EventQueue interface and make tap() async. ([#914](https://github.com/a2aproject/a2a-python/issues/914)) ([9ccf99c](https://github.com/a2aproject/a2a-python/commit/9ccf99c63d4e556eadea064de6afa0b4fc4e19d6)), closes [#869](https://github.com/a2aproject/a2a-python/issues/869)
+* EventQueue - unify implementation between python versions ([#877](https://github.com/a2aproject/a2a-python/issues/877)) ([7437b88](https://github.com/a2aproject/a2a-python/commit/7437b88328fc71ed07e8e50f22a2eb0df4bf4201)), closes [#869](https://github.com/a2aproject/a2a-python/issues/869)
+* EventQueue is now a simple interface with single enqueue_event method. ([#944](https://github.com/a2aproject/a2a-python/issues/944)) ([f0e1d74](https://github.com/a2aproject/a2a-python/commit/f0e1d74802e78a4e9f4c22cbc85db104137e0cd2))
+* Implementation of DefaultRequestHandlerV2 ([#933](https://github.com/a2aproject/a2a-python/issues/933)) ([462eb3c](https://github.com/a2aproject/a2a-python/commit/462eb3cb7b6070c258f5672aa3b0aa59e913037c)), closes [#869](https://github.com/a2aproject/a2a-python/issues/869)
+* InMemoryTaskStore creates a copy of Task by default to make it consistent with database task stores  ([#887](https://github.com/a2aproject/a2a-python/issues/887)) ([8c65e84](https://github.com/a2aproject/a2a-python/commit/8c65e84fb844251ce1d8f04d26dbf465a89b9a29)), closes [#869](https://github.com/a2aproject/a2a-python/issues/869)
+* merge metadata of new and old artifact when append=True ([#945](https://github.com/a2aproject/a2a-python/issues/945)) ([cc094aa](https://github.com/a2aproject/a2a-python/commit/cc094aa51caba8107b63982e9b79256f7c2d331a))
+* **server:** add async context manager support to EventQueue ([#743](https://github.com/a2aproject/a2a-python/issues/743)) ([f68b22f](https://github.com/a2aproject/a2a-python/commit/f68b22f0323ed4ff9267fabcf09c9d873baecc39))
+* **server:** validate presence according to `google.api.field_behavior` annotations ([#870](https://github.com/a2aproject/a2a-python/issues/870)) ([4586c3e](https://github.com/a2aproject/a2a-python/commit/4586c3ec0b507d64caa3ced72d68a34ec5b37a11))
+* Simplify ActiveTask.subscribe() ([#958](https://github.com/a2aproject/a2a-python/issues/958)) ([62e5e59](https://github.com/a2aproject/a2a-python/commit/62e5e59a30b11b9b493f7bf969aa13173ce51b9c))
+* Support AgentExectuor enqueue of a Task object. ([#960](https://github.com/a2aproject/a2a-python/issues/960)) ([12ce017](https://github.com/a2aproject/a2a-python/commit/12ce0179056db9d9ba2abdd559cb5a4bb5a20ddf))
+* Support Message-only simplified execution without creating Task ([#956](https://github.com/a2aproject/a2a-python/issues/956)) ([354fdfb](https://github.com/a2aproject/a2a-python/commit/354fdfb68dd0c7894daaac885a06dfed0ab839c8))
+* Unhandled exception in AgentExecutor marks task as failed ([#943](https://github.com/a2aproject/a2a-python/issues/943)) ([4fc6b54](https://github.com/a2aproject/a2a-python/commit/4fc6b54fd26cc83d810d81f923579a1cd4853b39))
+
+
+### Bug Fixes
+
+* Add `packaging` to base dependencies ([#897](https://github.com/a2aproject/a2a-python/issues/897)) ([7a9aec7](https://github.com/a2aproject/a2a-python/commit/7a9aec7779448faa85a828d1076bcc47cda7bdbb))
+* **client:** do not mutate SendMessageRequest in BaseClient.send_message ([#949](https://github.com/a2aproject/a2a-python/issues/949)) ([94537c3](https://github.com/a2aproject/a2a-python/commit/94537c382be4160332279a44d83254feeb0b8037))
+* fix `athrow()` RuntimeError on streaming responses ([#912](https://github.com/a2aproject/a2a-python/issues/912)) ([ca7edc3](https://github.com/a2aproject/a2a-python/commit/ca7edc3b670538ce0f051c49f2224173f186d3f4))
+* fix docstrings related to `CallContextBuilder` args in constructors and make ServerCallContext mandatory in `compat` folder ([#907](https://github.com/a2aproject/a2a-python/issues/907)) ([9cade9b](https://github.com/a2aproject/a2a-python/commit/9cade9bdadfb94f2f857ec2dc302a2c402e7f0ea))
+* fix error handling for gRPC and SSE streaming ([#879](https://github.com/a2aproject/a2a-python/issues/879)) ([2b323d0](https://github.com/a2aproject/a2a-python/commit/2b323d0b191279fb5f091199aa30865299d5fcf2))
+* fix JSONRPC error handling ([#957](https://github.com/a2aproject/a2a-python/issues/957)) ([6c807d5](https://github.com/a2aproject/a2a-python/commit/6c807d51c49ac294a6e3cbec34be101d4f91870d))
+* fix REST error handling ([#893](https://github.com/a2aproject/a2a-python/issues/893)) ([405be3f](https://github.com/a2aproject/a2a-python/commit/405be3fa3ef8c60f730452b956879beeaecc5957))
+* handle SSE errors occurred after stream started ([#894](https://github.com/a2aproject/a2a-python/issues/894)) ([3a68d8f](https://github.com/a2aproject/a2a-python/commit/3a68d8f916d96ae135748ee2b9b907f8dace4fa7))
+* remove the use of deprecated types from VertexTaskStore ([#889](https://github.com/a2aproject/a2a-python/issues/889)) ([6d49122](https://github.com/a2aproject/a2a-python/commit/6d49122238a5e7d497c5d002792732446071dcb2))
+* Remove unconditional SQLAlchemy dependency from SDK core ([#898](https://github.com/a2aproject/a2a-python/issues/898)) ([ab762f0](https://github.com/a2aproject/a2a-python/commit/ab762f0448911a9ac05b6e3fec0104615e0ec557)), closes [#883](https://github.com/a2aproject/a2a-python/issues/883)
+* remove unused import and request for FastAPI in pyproject ([#934](https://github.com/a2aproject/a2a-python/issues/934)) ([fe5de77](https://github.com/a2aproject/a2a-python/commit/fe5de77a1d457958fe14fec61b0d8aa41c5ec300))
+* replace stale entry in a2a.types.__all__ with actual import name ([#902](https://github.com/a2aproject/a2a-python/issues/902)) ([05cd5e9](https://github.com/a2aproject/a2a-python/commit/05cd5e9b73b55d2863c58c13be0c7dd21d8124bb))
+* wrong method name for ExtendedAgentCard endpoint in JsonRpc compat version ([#931](https://github.com/a2aproject/a2a-python/issues/931)) ([5d22186](https://github.com/a2aproject/a2a-python/commit/5d22186b8ee0f64b744512cdbe7ab6176fa97c60))
+
+
+### Documentation
+
+* add Database Migration Documentation ([#864](https://github.com/a2aproject/a2a-python/issues/864)) ([fd12dff](https://github.com/a2aproject/a2a-python/commit/fd12dffa3a7aa93816c762a155ed9b505086b924))
+
+
+### Miscellaneous Chores
+
+* release 1.0.0-alpha.1 ([a61f6d4](https://github.com/a2aproject/a2a-python/commit/a61f6d4e2e7ce1616a35c3a2ede64a4c9067048a))
+
+
+### Code Refactoring
+
+* **client:** make ClientConfig.push_notification_config singular ([#955](https://github.com/a2aproject/a2a-python/issues/955)) ([be4c5ff](https://github.com/a2aproject/a2a-python/commit/be4c5ff17a2f58e20d5d333a5e8e7bfcaa58c6c0))
+* **client:** remove `ClientTaskManager` and `Consumers` from client ([#916](https://github.com/a2aproject/a2a-python/issues/916)) ([97058bb](https://github.com/a2aproject/a2a-python/commit/97058bb444ea663d77c3b62abcf2fd0c30a1a526)), closes [#734](https://github.com/a2aproject/a2a-python/issues/734)
+* **client:** reorganize ClientFactory API ([#947](https://github.com/a2aproject/a2a-python/issues/947)) ([01b3b2c](https://github.com/a2aproject/a2a-python/commit/01b3b2c0e196b0aab4f1f0dc22a95c09c7ee914d))
+* **server:** add build_user function to DefaultContextBuilder to allow A2A user creation customization ([#925](https://github.com/a2aproject/a2a-python/issues/925)) ([2648c5e](https://github.com/a2aproject/a2a-python/commit/2648c5e50281ceb9795b10a726bd23670b363ae1))
+* **server:** migrate from Application wrappers to Starlette route-based endpoints for jsonrpc ([#873](https://github.com/a2aproject/a2a-python/issues/873)) ([734d062](https://github.com/a2aproject/a2a-python/commit/734d0621dc6170d10d0cdf9c074e5ae28531fc71))
+* **server:** migrate from Application wrappers to Starlette route-based endpoints for rest ([#892](https://github.com/a2aproject/a2a-python/issues/892)) ([4be2064](https://github.com/a2aproject/a2a-python/commit/4be2064b5d511e0b4617507ed0c376662688ebeb))
+
+## 1.0.0-alpha.0 (2026-03-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* **spec**: upgrade SDK to A2A 1.0 spec and use proto-based types ([#572](https://github.com/a2aproject/a2a-python/issues/572), [#665](https://github.com/a2aproject/a2a-python/issues/665), [#804](https://github.com/a2aproject/a2a-python/issues/804), [#765](https://github.com/a2aproject/a2a-python/issues/765))
+* **client:** introduce ServiceParameters for extensions and include it in ClientCallContext ([#784](https://github.com/a2aproject/a2a-python/issues/784))
+* **client:** rename "callback" -> "push_notification_config" ([#749](https://github.com/a2aproject/a2a-python/issues/749))
+* **client:** transport agnostic interceptors ([#796](https://github.com/a2aproject/a2a-python/issues/796)) ([a910cbc](https://github.com/a2aproject/a2a-python/commit/a910cbcd48f6017c19bb4c87be3c62b7d7e9810d))
+* add `protocol_version` column to Task and PushNotificationConfig models and create a migration ([#789](https://github.com/a2aproject/a2a-python/issues/789)) ([2e2d431](https://github.com/a2aproject/a2a-python/commit/2e2d43190930612495720c372dd2d9921c0311f9))
+* **server:** implement `Resource Scoping` for tasks and push notifications ([#709](https://github.com/a2aproject/a2a-python/issues/709)) ([f0d4669](https://github.com/a2aproject/a2a-python/commit/f0d4669224841657341e7f773b427e2128ab0ed8))
+
+### Features
+
+* add GetExtendedAgentCardRequest as input parameter to GetExtendedAgentCard method ([#767](https://github.com/a2aproject/a2a-python/issues/767)) ([13a092f](https://github.com/a2aproject/a2a-python/commit/13a092f5a5d7b2b2654c69a99dc09ed9d928ffe5))
+* add validation for the JSON-RPC version ([#808](https://github.com/a2aproject/a2a-python/issues/808)) ([6eb7e41](https://github.com/a2aproject/a2a-python/commit/6eb7e4155517be8ff0766c0a929fd7d7b4a52db5))
+* **client:** expose close() and async context manager support on abstract Client ([#719](https://github.com/a2aproject/a2a-python/issues/719)) ([e25ba7b](https://github.com/a2aproject/a2a-python/commit/e25ba7be57fe28ab101a9726972f7c8620468a52))
+* **compat:** AgentCard backward compatibility helpers and tests ([#760](https://github.com/a2aproject/a2a-python/issues/760)) ([81f3494](https://github.com/a2aproject/a2a-python/commit/81f349482fc748c93b073a9f2af715e7333b0dfb))
+* **compat:** GRPC client compatible with 0.3 server ([#779](https://github.com/a2aproject/a2a-python/issues/779)) ([0ebca93](https://github.com/a2aproject/a2a-python/commit/0ebca93670703490df1e536d57b4cd83595d0e51))
+* **compat:** GRPC server compatible with 0.3 client ([#772](https://github.com/a2aproject/a2a-python/issues/772)) ([80d827a](https://github.com/a2aproject/a2a-python/commit/80d827ae4ebb6515bf8dcb10e50ba27be8b6b41b))
+* **compat:** legacy v0.3 protocol models, conversion logic and utilities ([#754](https://github.com/a2aproject/a2a-python/issues/754)) ([26835ad](https://github.com/a2aproject/a2a-python/commit/26835ad3f6d256ff6b84858d690204da66854eb9))
+* **compat:** REST and JSONRPC clients compatible with 0.3 servers ([#798](https://github.com/a2aproject/a2a-python/issues/798)) ([08794f7](https://github.com/a2aproject/a2a-python/commit/08794f7bd05c223f8621d4b6924fc9a80d898a39))
+* **compat:** REST and JSONRPC servers compatible with 0.3 clients ([#795](https://github.com/a2aproject/a2a-python/issues/795)) ([9856054](https://github.com/a2aproject/a2a-python/commit/9856054f8398162b01e38b65b2e090adb95f1e8b))
+* **compat:** set a2a-version header to 1.0.0 ([#764](https://github.com/a2aproject/a2a-python/issues/764)) ([4cb68aa](https://github.com/a2aproject/a2a-python/commit/4cb68aa26a80a1121055d11f067824610a035ee6))
+* **compat:** unify v0.3 REST url prefix and expand cross-version tests ([#820](https://github.com/a2aproject/a2a-python/issues/820)) ([0925f0a](https://github.com/a2aproject/a2a-python/commit/0925f0aa27800df57ca766a1f7b0a36071e3752c))
+* database forward compatibility: make `owner` field optional ([#812](https://github.com/a2aproject/a2a-python/issues/812)) ([cc29d1f](https://github.com/a2aproject/a2a-python/commit/cc29d1f2fb1dbaeae80a08b783e3ba05bc4a757e))
+* handle tenant in Client ([#758](https://github.com/a2aproject/a2a-python/issues/758)) ([5b354e4](https://github.com/a2aproject/a2a-python/commit/5b354e403a717c3c6bf47a291bef028c8c6a9d94))
+* implement missing push notifications related methods ([#711](https://github.com/a2aproject/a2a-python/issues/711)) ([041f0f5](https://github.com/a2aproject/a2a-python/commit/041f0f53bcf5fc2e74545d653bfeeba8d2d85c79))
+* implement rich gRPC error details per A2A v1.0 spec ([#790](https://github.com/a2aproject/a2a-python/issues/790)) ([245eca3](https://github.com/a2aproject/a2a-python/commit/245eca30b70ccd1809031325dc9b86f23a9bac2a))
+* **rest:** add tenant support to rest ([#773](https://github.com/a2aproject/a2a-python/issues/773)) ([4771b5a](https://github.com/a2aproject/a2a-python/commit/4771b5aa1dbae51fdb5f7ff4324136d4db31e76f))
+* send task as a first subscribe event ([#716](https://github.com/a2aproject/a2a-python/issues/716)) ([e71ac62](https://github.com/a2aproject/a2a-python/commit/e71ac6266f506ec843d00409d606acb22fec5f78))
+* **server, grpc:** Implement tenant context propagation for gRPC requests. ([#781](https://github.com/a2aproject/a2a-python/issues/781)) ([164f919](https://github.com/a2aproject/a2a-python/commit/164f9197f101e3db5c487c4dede45b8729475a8c))
+* **server, json-rpc:** Implement tenant context propagation for JSON-RPC requests. ([#778](https://github.com/a2aproject/a2a-python/issues/778)) ([72a330d](https://github.com/a2aproject/a2a-python/commit/72a330d2c073ece51e093542c41ec171c667f312))
+* **server:** add v0.3 legacy compatibility for database models ([#783](https://github.com/a2aproject/a2a-python/issues/783)) ([08c491e](https://github.com/a2aproject/a2a-python/commit/08c491eb6c732f7a872e562cd0fbde01df791cca))
+* **spec:** add `tasks/list` method with filtering and pagination to the specification ([#511](https://github.com/a2aproject/a2a-python/issues/511)) ([d5818e5](https://github.com/a2aproject/a2a-python/commit/d5818e5233d9f0feeab3161cc3b1be3ae236d887))
+* use StreamResponse as push notifications payload ([#724](https://github.com/a2aproject/a2a-python/issues/724)) ([a149a09](https://github.com/a2aproject/a2a-python/commit/a149a0923c14480888c48156710413967dfebc36))
+* **rest:** update REST error handling to use `google.rpc.Status` ([#838](https://github.com/a2aproject/a2a-python/issues/838)) ([ea7d3ad](https://github.com/a2aproject/a2a-python/commit/ea7d3add16e137ea6c71272d845bdc9bfb5853c8))
+
+
+### Bug Fixes
+
+* add history length and page size validations ([#726](https://github.com/a2aproject/a2a-python/issues/726)) ([e67934b](https://github.com/a2aproject/a2a-python/commit/e67934b06442569a993455753ee4a360ac89b69f))
+* allign error codes with the latest spec ([#826](https://github.com/a2aproject/a2a-python/issues/826)) ([709b1ff](https://github.com/a2aproject/a2a-python/commit/709b1ff57b7604889da0c532a6b33954ee65491b))
+* **client:** align send_message signature with BaseClient ([#740](https://github.com/a2aproject/a2a-python/issues/740)) ([57cb529](https://github.com/a2aproject/a2a-python/commit/57cb52939ef9779eebd993a078cfffb854663e3e))
+* get_agent_card trailing slash when agent_card_path="" ([#799](https://github.com/a2aproject/a2a-python/issues/799)) ([#800](https://github.com/a2aproject/a2a-python/issues/800)) ([a55c97e](https://github.com/a2aproject/a2a-python/commit/a55c97e4d2031d74b57835710e07344484fb9fb6))
+* handle parsing error in REST ([#806](https://github.com/a2aproject/a2a-python/issues/806)) ([bbd09f2](https://github.com/a2aproject/a2a-python/commit/bbd09f232f556c527096eea5629688e29abb3f2f))
+* Improve error handling for Timeout exceptions on REST and JSON-RPC clients ([#690](https://github.com/a2aproject/a2a-python/issues/690)) ([2acd838](https://github.com/a2aproject/a2a-python/commit/2acd838796d44ab9bfe6ba8c8b4ea0c2571a59dc))
+* Improve streaming errors handling ([#576](https://github.com/a2aproject/a2a-python/issues/576)) ([7ea7475](https://github.com/a2aproject/a2a-python/commit/7ea7475091df2ee40d3035ef1bc34ee2f86524ee))
+* properly handle unset and zero history length ([#717](https://github.com/a2aproject/a2a-python/issues/717)) ([72a1007](https://github.com/a2aproject/a2a-python/commit/72a100797e513730dbeb80477c943b36cf79c957))
+* return entire history when history_length=0 ([#537](https://github.com/a2aproject/a2a-python/issues/537)) ([acdc0de](https://github.com/a2aproject/a2a-python/commit/acdc0de4fa03d34a6b287ab252ff51b19c3016b5))
+* return mandatory fields from list_tasks ([#710](https://github.com/a2aproject/a2a-python/issues/710)) ([6132053](https://github.com/a2aproject/a2a-python/commit/6132053976c4e8b2ce7cad9b87072fa8fb5a2cf0))
+* taskslist error on invalid page token and response serialization ([#814](https://github.com/a2aproject/a2a-python/issues/814)) ([a102d31](https://github.com/a2aproject/a2a-python/commit/a102d31abe8d72d18ec706f083855b7aad8bbbd4))
+* use correct REST path for Get Extended Agent Card operation ([#769](https://github.com/a2aproject/a2a-python/issues/769)) ([ced3f99](https://github.com/a2aproject/a2a-python/commit/ced3f998a9d0b97495ebded705422459aa8d7398))
+* Use POST method for REST endpoint /tasks/{id}:subscribe ([#843](https://github.com/a2aproject/a2a-python/issues/843)) ([a0827d0](https://github.com/a2aproject/a2a-python/commit/a0827d0d2887749c922e5cafbc897e465ba8fe17))
+
+## [0.3.26](https://github.com/a2aproject/a2a-python/compare/v0.3.25...v0.3.26) (2026-04-09)
+
+
+### Features
+
+* Add support for more Task Message and Artifact fields in the Vertex Task Store ([#908](https://github.com/a2aproject/a2a-python/issues/908)) ([5e0dcd7](https://github.com/a2aproject/a2a-python/commit/5e0dcd798fcba16a8092b0b4c2d3d8026ca287de))
+
+
+### Bug Fixes
+
+* remove the use of deprecated types from VertexTaskStore ([#889](https://github.com/a2aproject/a2a-python/issues/889)) ([6d49122](https://github.com/a2aproject/a2a-python/commit/6d49122238a5e7d497c5d002792732446071dcb2))
+
+## [0.3.25](https://github.com/a2aproject/a2a-python/compare/v0.3.24...v0.3.25) (2026-03-10)
+
+
+### Features
+
+* Implement a vertex based task store ([#752](https://github.com/a2aproject/a2a-python/issues/752)) ([fa14dbf](https://github.com/a2aproject/a2a-python/commit/fa14dbf46b603f288a1f1c474401483bf53950e4))
+
+
+### Bug Fixes
+
+* return background task from consume_and_break_on_interrupt to prevent GC ([#775](https://github.com/a2aproject/a2a-python/issues/775)) ([a236d4d](https://github.com/a2aproject/a2a-python/commit/a236d4df8dceb2db1e1170e0b57599f3837ebd71))
+* use default_factory for mutable field defaults in ServerCallContext ([#744](https://github.com/a2aproject/a2a-python/issues/744)) ([22b25d6](https://github.com/a2aproject/a2a-python/commit/22b25d653e57e2d1453bbc282052e51dbd904ac6))
+
+## [0.3.24](https://github.com/a2aproject/a2a-python/compare/v0.3.23...v0.3.24) (2026-02-20)
+
+
+### Bug Fixes
+
+* **core:** preserve legitimate falsy values in _clean_empty ([#713](https://github.com/a2aproject/a2a-python/issues/713)) ([7632f55](https://github.com/a2aproject/a2a-python/commit/7632f55572641d8fbc353ee08ef2b1f6b75c38b6))
+* **deps:** `DeprecationWarning` on `HTTP_413_REQUEST_ENTITY_TOO_LARGE` ([#693](https://github.com/a2aproject/a2a-python/issues/693)) ([9968f9c](https://github.com/a2aproject/a2a-python/commit/9968f9c07f105bae8a6b296aeb6dea873b3b88b0))
+
+## [0.3.23](https://github.com/a2aproject/a2a-python/compare/v0.3.22...v0.3.23) (2026-02-13)
+
+
+### Features
+
+* add async context manager support to BaseClient ([#688](https://github.com/a2aproject/a2a-python/issues/688)) ([ae9dc88](https://github.com/a2aproject/a2a-python/commit/ae9dc8897885ad26461083682dd7ba008d5af3cb))
+* add async context manager support to ClientTransport ([#682](https://github.com/a2aproject/a2a-python/issues/682)) ([2e45c0d](https://github.com/a2aproject/a2a-python/commit/2e45c0d54e47f1725b13c67c8e509b0e6e61efb6))
+* support async card modifiers ([#654](https://github.com/a2aproject/a2a-python/issues/654)) ([a802500](https://github.com/a2aproject/a2a-python/commit/a802500b3ad82845c1a6fc155f80e75a20a1bcab))
+* support disabling OTel instrumentation via env var ([#611](https://github.com/a2aproject/a2a-python/issues/611)) ([72216b9](https://github.com/a2aproject/a2a-python/commit/72216b988c0681e07d26ea8d5489a619d1ad6dda))
+
+
+### Bug Fixes
+
+* do not crash on SSE comment line ([#636](https://github.com/a2aproject/a2a-python/issues/636)) ([3dcb847](https://github.com/a2aproject/a2a-python/commit/3dcb84772fdc8a4d3b63b518ed491e5ed3d38d0a))
+* gRPC metadata header casing and invocation_metadata() call ([#676](https://github.com/a2aproject/a2a-python/issues/676)) ([390b763](https://github.com/a2aproject/a2a-python/commit/390b763d106eae3b2ca8ca78a2d0bfdc68f8fe2c))
+* Improve error handling for Timeout exceptions on REST and JSON-RPC clients ([#690](https://github.com/a2aproject/a2a-python/issues/690)) ([2acd838](https://github.com/a2aproject/a2a-python/commit/2acd838796d44ab9bfe6ba8c8b4ea0c2571a59dc))
+* map rejected task state in proto converters ([#668](https://github.com/a2aproject/a2a-python/issues/668)) ([957e92b](https://github.com/a2aproject/a2a-python/commit/957e92b9059792c44a40bbab18160996f5512145)), closes [#625](https://github.com/a2aproject/a2a-python/issues/625)
+* **server:** fix deadlocks on agent execution failure in non-streaming ([#614](https://github.com/a2aproject/a2a-python/issues/614)) ([d3c973f](https://github.com/a2aproject/a2a-python/commit/d3c973fe72afc0142f8a4c94d0c0fbe4ba2ddfe8))
+
+
+### Documentation
+
+* explicitly mention supported spec version and transports in readme ([#681](https://github.com/a2aproject/a2a-python/issues/681)) ([c91d4fb](https://github.com/a2aproject/a2a-python/commit/c91d4fba517190d8f7c76b42ea26914a4275f1d5)), closes [#677](https://github.com/a2aproject/a2a-python/issues/677)
+* Update README to include Code Wiki badge ([2698cc0](https://github.com/a2aproject/a2a-python/commit/2698cc04f15282fb358018f06bd88ae159d987b4))
+
+## [0.3.22](https://github.com/a2aproject/a2a-python/compare/v0.3.21...v0.3.22) (2025-12-16)
+
+
+### Features
+
+* Add custom ID generators to SimpleRequestContextBuilder ([#594](https://github.com/a2aproject/a2a-python/issues/594)) ([04bcafc](https://github.com/a2aproject/a2a-python/commit/04bcafc737cf426d9975c76e346335ff992363e2))
+
+
+### Code Refactoring
+
+* Move agent card signature verification into `A2ACardResolver` ([6fa6a6c](https://github.com/a2aproject/a2a-python/commit/6fa6a6cf3875bdf7bfc51fb1a541a3f3e8381dc0))
+
+## [0.3.21](https://github.com/a2aproject/a2a-python/compare/v0.3.20...v0.3.21) (2025-12-12)
+
+
+### Documentation
+
+* Fixing typos ([#586](https://github.com/a2aproject/a2a-python/issues/586)) ([5fea21f](https://github.com/a2aproject/a2a-python/commit/5fea21fb34ecea55e588eb10139b5d47020a76cb))
+
+## [0.3.20](https://github.com/a2aproject/a2a-python/compare/v0.3.19...v0.3.20) (2025-12-03)
+
+
+### Bug Fixes
+
+* Improve streaming errors handling ([#576](https://github.com/a2aproject/a2a-python/issues/576)) ([7ea7475](https://github.com/a2aproject/a2a-python/commit/7ea7475091df2ee40d3035ef1bc34ee2f86524ee))
+
+## [0.3.19](https://github.com/a2aproject/a2a-python/compare/v0.3.18...v0.3.19) (2025-11-25)
+
+
+### Bug Fixes
+
+* **jsonrpc, rest:** `extensions` support in `get_card` methods in `json-rpc` and `rest` transports ([#564](https://github.com/a2aproject/a2a-python/issues/564)) ([847f18e](https://github.com/a2aproject/a2a-python/commit/847f18eff59985f447c39a8e5efde87818b68d15))
+
+## [0.3.18](https://github.com/a2aproject/a2a-python/compare/v0.3.17...v0.3.18) (2025-11-24)
+
+
+### Bug Fixes
+
+* return updated `agent_card` in `JsonRpcTransport.get_card()` ([#552](https://github.com/a2aproject/a2a-python/issues/552)) ([0ce239e](https://github.com/a2aproject/a2a-python/commit/0ce239e98f67ccbf154f2edcdbcee43f3b080ead))
+
+## [0.3.17](https://github.com/a2aproject/a2a-python/compare/v0.3.16...v0.3.17) (2025-11-24)
+
+
+### Features
+
+* **client:** allow specifying `history_length` via call-site `MessageSendConfiguration` in `BaseClient.send_message` ([53bbf7a](https://github.com/a2aproject/a2a-python/commit/53bbf7ae3ad58fb0c10b14da05cf07c0a7bd9651))
+
+## [0.3.16](https://github.com/a2aproject/a2a-python/compare/v0.3.15...v0.3.16) (2025-11-21)
+
+
+### Bug Fixes
+
+* Ensure metadata propagation for `Task` `ToProto` and `FromProto` conversion ([#557](https://github.com/a2aproject/a2a-python/issues/557)) ([fc31d03](https://github.com/a2aproject/a2a-python/commit/fc31d03e8c6acb68660f6d1924262e16933c5d50))
+
+## [0.3.15](https://github.com/a2aproject/a2a-python/compare/v0.3.14...v0.3.15) (2025-11-19)
+
+
+### Features
+
+* Add client-side extension support ([#525](https://github.com/a2aproject/a2a-python/issues/525)) ([9a92bd2](https://github.com/a2aproject/a2a-python/commit/9a92bd238e7560b195165ac5f78742981760525e))
+* **rest, jsonrpc:** Add client-side extension support ([9a92bd2](https://github.com/a2aproject/a2a-python/commit/9a92bd238e7560b195165ac5f78742981760525e))
+
+## [0.3.14](https://github.com/a2aproject/a2a-python/compare/v0.3.13...v0.3.14) (2025-11-17)
+
+
+### Features
+
+* **jsonrpc:** add option to disable oversized payload check in JSONRPC applications ([ba142df](https://github.com/a2aproject/a2a-python/commit/ba142df821d1c06be0b96e576fd43015120fcb0b))
+
+## [0.3.13](https://github.com/a2aproject/a2a-python/compare/v0.3.12...v0.3.13) (2025-11-13)
+
+
+### Bug Fixes
+
+* return entire history when history_length=0 ([#537](https://github.com/a2aproject/a2a-python/issues/537)) ([acdc0de](https://github.com/a2aproject/a2a-python/commit/acdc0de4fa03d34a6b287ab252ff51b19c3016b5))
+
+## [0.3.12](https://github.com/a2aproject/a2a-python/compare/v0.3.11...v0.3.12) (2025-11-12)
+
+
+### Bug Fixes
+
+* **grpc:** Add `extensions` to `Artifact` converters. ([#523](https://github.com/a2aproject/a2a-python/issues/523)) ([c03129b](https://github.com/a2aproject/a2a-python/commit/c03129b99a663ae1f1ae72f20e4ead7807ede941))
+
+## [0.3.11](https://github.com/a2aproject/a2a-python/compare/v0.3.10...v0.3.11) (2025-11-07)
+
+
+### Bug Fixes
+
+* add metadata to send message request ([12b4a1d](https://github.com/a2aproject/a2a-python/commit/12b4a1d565a53794f5b55c8bd1728221c906ed41))
+
+## [0.3.10](https://github.com/a2aproject/a2a-python/compare/v0.3.9...v0.3.10) (2025-10-21)
+
+
+### Features
+
+* add `get_artifact_text()` helper method ([9155888](https://github.com/a2aproject/a2a-python/commit/9155888d258ca4d047002997e6674f3f15a67232))
+* Add a `ClientFactory.connect()` method for easy client creation ([d585635](https://github.com/a2aproject/a2a-python/commit/d5856359034f4d3d1e4578804727f47a3cd7c322))
+
+
+### Bug Fixes
+
+* change `MAX_CONTENT_LENGTH` (for file attachment) in json-rpc to be larger size (10mb) ([#518](https://github.com/a2aproject/a2a-python/issues/518)) ([5b81385](https://github.com/a2aproject/a2a-python/commit/5b813856b4b4e07510a4ef41980d388e47c73b8e))
+* correct `new_artifact` methods signature ([#503](https://github.com/a2aproject/a2a-python/issues/503)) ([ee026aa](https://github.com/a2aproject/a2a-python/commit/ee026aa356042b9eb212eee59fa5135b280a3077))
+
+
+### Code Refactoring
+
+* **utils:** move part helpers to their own file ([9155888](https://github.com/a2aproject/a2a-python/commit/9155888d258ca4d047002997e6674f3f15a67232))
+
+## [0.3.9](https://github.com/a2aproject/a2a-python/compare/v0.3.8...v0.3.9) (2025-10-15)
+
+
+### Features
+
+* custom ID generators ([051ab20](https://github.com/a2aproject/a2a-python/commit/051ab20c395daa2807b0233cf1c53493e41b60c2))
+
+
+### Bug Fixes
+
+* apply `history_length` for `message/send` requests ([#498](https://github.com/a2aproject/a2a-python/issues/498)) ([a49f94e](https://github.com/a2aproject/a2a-python/commit/a49f94ef23d81b8375e409b1c1e51afaf1da1956))
+* **client:** `A2ACardResolver.get_agent_card` will autopopulate with `agent_card_path` when `relative_card_path` is empty ([#508](https://github.com/a2aproject/a2a-python/issues/508)) ([ba24ead](https://github.com/a2aproject/a2a-python/commit/ba24eadb5b6fcd056a008e4cbcef03b3f72a37c3))
+
+
+### Documentation
+
+* Fix Docstring formatting for code samples ([#492](https://github.com/a2aproject/a2a-python/issues/492)) ([dca66c3](https://github.com/a2aproject/a2a-python/commit/dca66c3100a2b9701a1c8b65ad6853769eefd511))
+
+## [0.3.8](https://github.com/a2aproject/a2a-python/compare/v0.3.7...v0.3.8) (2025-10-06)
+
+
+### Bug Fixes
+
+* Add `__str__` and `__repr__` methods to `ServerError` ([#489](https://github.com/a2aproject/a2a-python/issues/489)) ([2c152c0](https://github.com/a2aproject/a2a-python/commit/2c152c0e636db828839dc3133756c558ab090c1a))
+* **grpc:** Fix missing extensions from protobuf ([#476](https://github.com/a2aproject/a2a-python/issues/476)) ([8dbc78a](https://github.com/a2aproject/a2a-python/commit/8dbc78a7a6d2036b0400873b50cfc95a59bdb192))
+* **rest:** send `historyLength=0` (avoid falsy omission) ([#480](https://github.com/a2aproject/a2a-python/issues/480)) ([ed28b59](https://github.com/a2aproject/a2a-python/commit/ed28b5922877c1c8386fd0a7e05471581905bc59)), closes [#479](https://github.com/a2aproject/a2a-python/issues/479)
+
+
+### Documentation
+
+* `a2a-sdk[all]` installation command in Readme ([#485](https://github.com/a2aproject/a2a-python/issues/485)) ([6ac9a7c](https://github.com/a2aproject/a2a-python/commit/6ac9a7ceb6aff1ca2f756cf75f58e169b8dcd43a))
+
+## [0.3.7](https://github.com/a2aproject/a2a-python/compare/v0.3.6...v0.3.7) (2025-09-22)
+
+
+### Bug Fixes
+
+* jsonrpc client send streaming request header and timeout field ([#475](https://github.com/a2aproject/a2a-python/issues/475)) ([675354a](https://github.com/a2aproject/a2a-python/commit/675354a4149f15eb3ba4ad277ded00ad501766dd))
+* Task state is not persisted to task store after client disconnect ([#472](https://github.com/a2aproject/a2a-python/issues/472)) ([5342ca4](https://github.com/a2aproject/a2a-python/commit/5342ca43398ec004597167f6b1a47525b69d1439)), closes [#464](https://github.com/a2aproject/a2a-python/issues/464)
+
+## [0.3.6](https://github.com/a2aproject/a2a-python/compare/v0.3.5...v0.3.6) (2025-09-09)
+
+
+### Features
+
+* add JSON-RPC `method` to `ServerCallContext.state` ([d62df7a](https://github.com/a2aproject/a2a-python/commit/d62df7a77e556f26556fc798a55dc6dacec21ea4))
+* **gRPC:** Add proto conversion utilities ([80fc33a](https://github.com/a2aproject/a2a-python/commit/80fc33aaef647826208d9020ef70e5e6592468e3))
+
+## [0.3.5](https://github.com/a2aproject/a2a-python/compare/v0.3.4...v0.3.5) (2025-09-08)
+
+
+### Bug Fixes
+
+* Prevent client disconnect from stopping task execution ([#440](https://github.com/a2aproject/a2a-python/issues/440)) ([58b4c81](https://github.com/a2aproject/a2a-python/commit/58b4c81746fc83e65f23f46308c47099697554ea)), closes [#296](https://github.com/a2aproject/a2a-python/issues/296)
+* **proto:** Adds metadata field to A2A DataPart proto ([#455](https://github.com/a2aproject/a2a-python/issues/455)) ([6d0ef59](https://github.com/a2aproject/a2a-python/commit/6d0ef593adaa22b2af0a5dd1a186646c180e3f8c))
+
+
+### Documentation
+
+* add example docs for `[@validate](https://github.com/validate)` and `[@validate](https://github.com/validate)_async_generator` ([#422](https://github.com/a2aproject/a2a-python/issues/422)) ([18289eb](https://github.com/a2aproject/a2a-python/commit/18289eb19bbdaebe5e36e26be686e698f223160b))
+* Restructure README ([9758f78](https://github.com/a2aproject/a2a-python/commit/9758f7896c5497d6ca49f798296a7380b2134b29))
+
+## [0.3.4](https://github.com/a2aproject/a2a-python/compare/v0.3.3...v0.3.4) (2025-09-02)
+
+
+### Features
+
+* Add `ServerCallContext` into task store operations ([#443](https://github.com/a2aproject/a2a-python/issues/443)) ([e3e5c4b](https://github.com/a2aproject/a2a-python/commit/e3e5c4b7dcb5106e943b9aeb8e761ed23cc166a2))
+* Add extensions support to `TaskUpdater.add_artifact` ([#436](https://github.com/a2aproject/a2a-python/issues/436)) ([598d8a1](https://github.com/a2aproject/a2a-python/commit/598d8a10e61be83bcb7bc9377365f7c42bc6af41))
+
+
+### Bug Fixes
+
+* convert auth_required state in proto utils ([#444](https://github.com/a2aproject/a2a-python/issues/444)) ([ac12f05](https://github.com/a2aproject/a2a-python/commit/ac12f0527d923800192c47dc1bd2e7eed262dfe6))
+* handle concurrent task completion during cancellation ([#449](https://github.com/a2aproject/a2a-python/issues/449)) ([f4c9c18](https://github.com/a2aproject/a2a-python/commit/f4c9c18cfef3ccab1ac7bb30cc7f8293cf3e3ef6))
+* Remove logger error from init on `rest_adapter` and `jsonrpc_app` ([#439](https://github.com/a2aproject/a2a-python/issues/439)) ([9193208](https://github.com/a2aproject/a2a-python/commit/9193208aabac2655a197732ff826e3c2d76f11b5))
+* resolve streaming endpoint deadlock by pre-consuming request body ([#426](https://github.com/a2aproject/a2a-python/issues/426)) ([4186731](https://github.com/a2aproject/a2a-python/commit/4186731df60f7adfcd25f19078d055aca26612a3))
+* Sync jsonrpc and rest implementation of authenticated agent card ([#441](https://github.com/a2aproject/a2a-python/issues/441)) ([9da9ecc](https://github.com/a2aproject/a2a-python/commit/9da9ecc96856a2474d75f986a1f45488c36f53e3))
+
+
+### Performance Improvements
+
+* Improve performance and code style for `proto_utils.py` ([#452](https://github.com/a2aproject/a2a-python/issues/452)) ([1e4b574](https://github.com/a2aproject/a2a-python/commit/1e4b57457386875b64362113356c615bc87315e3))
+
+## [0.3.3](https://github.com/a2aproject/a2a-python/compare/v0.3.2...v0.3.3) (2025-08-22)
+
+
+### Features
+
+* Update proto conversion utilities ([#424](https://github.com/a2aproject/a2a-python/issues/424)) ([a3e7e1e](https://github.com/a2aproject/a2a-python/commit/a3e7e1ef2684f979a3b8cbde1f9fd24ce9154e40))
+
+
+### Bug Fixes
+
+* fixing JSONRPC error mapping ([#414](https://github.com/a2aproject/a2a-python/issues/414)) ([d2e869f](https://github.com/a2aproject/a2a-python/commit/d2e869f567a84f59967cf59a044d6ca1e0d00daf))
+* Revert code that enforces uuid structure on context id in tasks ([#429](https://github.com/a2aproject/a2a-python/issues/429)) ([e3a7207](https://github.com/a2aproject/a2a-python/commit/e3a7207164503f64900feaa4ef470d37fb2bb145)), closes [#427](https://github.com/a2aproject/a2a-python/issues/427)
+
+
+### Performance Improvements
+
+* Optimize logging performance and modernize string formatting ([#411](https://github.com/a2aproject/a2a-python/issues/411)) ([3ffae8f](https://github.com/a2aproject/a2a-python/commit/3ffae8f8046aef20e559e19c21a5f9464a2c89ca))
+
+
+### Reverts
+
+* Revert "chore(gRPC): Update a2a.proto to include metadata on GetTaskRequest" ([#428](https://github.com/a2aproject/a2a-python/issues/428)) ([39c6b43](https://github.com/a2aproject/a2a-python/commit/39c6b430c6b57e84255f56894dcc46a740a53f9b))
+
+## [0.3.2](https://github.com/a2aproject/a2a-python/compare/v0.3.1...v0.3.2) (2025-08-20)
+
+
+### Bug Fixes
+
+* Add missing mime_type and name in proto conversion utils ([#408](https://github.com/a2aproject/a2a-python/issues/408)) ([72b2ee7](https://github.com/a2aproject/a2a-python/commit/72b2ee75dccfc8399edaa0837a025455b4b53a17))
+* Add name field to FilePart protobuf message ([#403](https://github.com/a2aproject/a2a-python/issues/403)) ([1dbe33d](https://github.com/a2aproject/a2a-python/commit/1dbe33d5cf2c74019b72c709f3427aeba54bf4e3))
+* Client hangs when implementing `AgentExecutor` and `await`ing twice in execute method ([#379](https://github.com/a2aproject/a2a-python/issues/379)) ([c147a83](https://github.com/a2aproject/a2a-python/commit/c147a83d3098e5ab2cd5b695a3bd71e17bf13b4c))
+* **grpc:** Update `CreateTaskPushNotificationConfig` endpoint to `/v1/{parent=tasks/*/pushNotificationConfigs}` ([#415](https://github.com/a2aproject/a2a-python/issues/415)) ([73dddc3](https://github.com/a2aproject/a2a-python/commit/73dddc3a3dc0b073d5559b3d0ec18ff4d20b6f7d))
+* make `event_consumer` tolerant to closed queues on py3.13 ([#407](https://github.com/a2aproject/a2a-python/issues/407)) ([a371461](https://github.com/a2aproject/a2a-python/commit/a371461c3b77aa9643c3a3378bb4405356863bff))
+* non-blocking `send_message` server handler not invoke push notification ([#394](https://github.com/a2aproject/a2a-python/issues/394)) ([db82a65](https://github.com/a2aproject/a2a-python/commit/db82a6582821a37aa8033d7db426557909ab10c6))
+* **proto:** Add `icon_url` to `a2a.proto` ([#416](https://github.com/a2aproject/a2a-python/issues/416)) ([00703e3](https://github.com/a2aproject/a2a-python/commit/00703e3df45ea7708613791ec35e843591333eca))
+* **spec:** Suggest Unique Identifier fields to be UUID ([#405](https://github.com/a2aproject/a2a-python/issues/405)) ([da14cea](https://github.com/a2aproject/a2a-python/commit/da14cea950f1af486e7891fa49199249d29b6f37))
+
+## [0.3.1](https://github.com/a2aproject/a2a-python/compare/v0.3.0...v0.3.1) (2025-08-13)
+
+
+### Features
+
+* Add agent card as a route in rest adapter ([ba93053](https://github.com/a2aproject/a2a-python/commit/ba93053850a767a8959bc634883008fcc1366e09))
+
+
+### Bug Fixes
+
+* gracefully handle task exceptions in event consumer ([#383](https://github.com/a2aproject/a2a-python/issues/383)) ([2508a9b](https://github.com/a2aproject/a2a-python/commit/2508a9b8ec1a1bfdc61e9012b7d68b33082b3981))
+* openapi working in sub-app ([#324](https://github.com/a2aproject/a2a-python/issues/324)) ([dec4b48](https://github.com/a2aproject/a2a-python/commit/dec4b487514db6cbb25f0c6fa7e1275a1ab0ba71))
+* Pass `message_length` param in `get_task()` ([#384](https://github.com/a2aproject/a2a-python/issues/384)) ([b6796b9](https://github.com/a2aproject/a2a-python/commit/b6796b9e1432ef8499eff454f869edf4427fd704))
+* relax protobuf dependency version requirement ([#381](https://github.com/a2aproject/a2a-python/issues/381)) ([0f55f55](https://github.com/a2aproject/a2a-python/commit/0f55f554ba9f6bf53fa3d9a91f66939f36e1ef2e))
+* Use HasField for simple message retrieval for grpc transport ([#380](https://github.com/a2aproject/a2a-python/issues/380)) ([3032aa6](https://github.com/a2aproject/a2a-python/commit/3032aa660f6f3b72dc7dd8b49b0e2f4d432c7a22))
+
+## [0.3.0](https://github.com/a2aproject/a2a-python/compare/v0.2.16...v0.3.0) (2025-07-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** Make opentelemetry an optional dependency ([#369](https://github.com/a2aproject/a2a-python/issues/369))
+* **spec:** Update Agent Card Well-Known Path to `/.well-known/agent-card.json` ([#320](https://github.com/a2aproject/a2a-python/issues/320))
+* Remove custom `__getattr__` and `__setattr__` for `camelCase` fields in `types.py` ([#335](https://github.com/a2aproject/a2a-python/issues/335))
+  * Use Script [`refactor_camel_to_snake.sh`](https://github.com/a2aproject/a2a-samples/blob/main/samples/python/refactor_camel_to_snake.sh) to convert your codebase to the new field names.
+* Add mTLS to SecuritySchemes, add oauth2 metadata url field, allow Skills to specify Security ([#362](https://github.com/a2aproject/a2a-python/issues/362))
+* Support for serving agent card at deprecated path ([#352](https://github.com/a2aproject/a2a-python/issues/352))
+
+### Features
+
+* Add `metadata` as parameter to `TaskUpdater.update_status()` ([#371](https://github.com/a2aproject/a2a-python/issues/371)) ([9444ed6](https://github.com/a2aproject/a2a-python/commit/9444ed629b925e285cd08aae3078ccd8b9bda6f2))
+* Add mTLS to SecuritySchemes, add oauth2 metadata url field, allow Skills to specify Security ([#362](https://github.com/a2aproject/a2a-python/issues/362)) ([be6c517](https://github.com/a2aproject/a2a-python/commit/be6c517e1f2db50a9217de91a9080810c36a7a1b))
+* Add RESTful API Serving ([#348](https://github.com/a2aproject/a2a-python/issues/348)) ([82a6b7c](https://github.com/a2aproject/a2a-python/commit/82a6b7cc9b83484a4ceabc2323e14e2ff0270f87))
+* Add server-side support for plumbing requested and activated extensions ([#333](https://github.com/a2aproject/a2a-python/issues/333)) ([4d5b92c](https://github.com/a2aproject/a2a-python/commit/4d5b92c61747edcabcfd825256a5339bb66c3e91))
+* Allow agent cards (default and extended) to be dynamic ([#365](https://github.com/a2aproject/a2a-python/issues/365)) ([ee92aab](https://github.com/a2aproject/a2a-python/commit/ee92aabe1f0babbba2fdbdefe21f2dbe7a899077))
+* Support for serving agent card at deprecated path ([#352](https://github.com/a2aproject/a2a-python/issues/352)) ([2444034](https://github.com/a2aproject/a2a-python/commit/2444034b7aa1d1af12bedecf40f27dafc4efec95))
+* support non-blocking `sendMessage` ([#349](https://github.com/a2aproject/a2a-python/issues/349)) ([70b4999](https://github.com/a2aproject/a2a-python/commit/70b499975f0811c8055ebd674bcb4070805506d4))
+* Type update to support fetching extended card ([#361](https://github.com/a2aproject/a2a-python/issues/361)) ([83304bb](https://github.com/a2aproject/a2a-python/commit/83304bb669403b51607973c1a965358d2e8f6ab0))
+
+
+### Bug Fixes
+
+* Add Input Validation for Task Context IDs in new_task Function ([#340](https://github.com/a2aproject/a2a-python/issues/340)) ([a7ed7ef](https://github.com/a2aproject/a2a-python/commit/a7ed7efed8fcdcc556616a5fc1cb8f968a116733))
+* **deps:** Reduce FastAPI library required version to `0.95.0` ([#372](https://github.com/a2aproject/a2a-python/issues/372)) ([a319334](https://github.com/a2aproject/a2a-python/commit/a31933456e08929f665ccec57ac07b8b9118990d))
+* Remove `DeprecationWarning` for regular properties ([#345](https://github.com/a2aproject/a2a-python/issues/345)) ([2806f3e](https://github.com/a2aproject/a2a-python/commit/2806f3eb7e1293924bb8637fd9c2cfe855858592))
+* **spec:** Add `SendMessageRequest.request` `json_name` mapping to `message` proto ([bc97cba](https://github.com/a2aproject/a2a-python/commit/bc97cba5945a49bea808feb2b1dc9eeb30007599))
+* **spec:** Add Transport enum to specification (https://github.com/a2aproject/A2A/pull/909) ([d9e463c](https://github.com/a2aproject/a2a-python/commit/d9e463cf1f8fbe486d37da3dd9009a19fe874ff0))
+
+
+### Documentation
+
+* Address typos in docstrings and docs. ([#370](https://github.com/a2aproject/a2a-python/issues/370)) ([ee48d68](https://github.com/a2aproject/a2a-python/commit/ee48d68d6c42a2a0c78f8a4666d1aded1a362e78))
+
+
+### Miscellaneous Chores
+
+* Add support for authenticated extended card method ([#356](https://github.com/a2aproject/a2a-python/issues/356)) ([b567e80](https://github.com/a2aproject/a2a-python/commit/b567e80735ae7e75f0bdb22f025b97895ce3b0dd))
+
+
+### Code Refactoring
+
+* **deps:** Make opentelemetry an optional dependency ([#369](https://github.com/a2aproject/a2a-python/issues/369)) ([9ad8b96](https://github.com/a2aproject/a2a-python/commit/9ad8b9623ffdc074ec561cbe65cfc2a2ba38bd0b))
+* Remove custom `__getattr__` and `__setattr__` for `camelCase` fields in `types.py` ([#335](https://github.com/a2aproject/a2a-python/issues/335)) ([cd94167](https://github.com/a2aproject/a2a-python/commit/cd941675d10868922adf14266901d035516a31cf))
+* **spec:** Update Agent Card Well-Known Path to `/.well-known/agent-card.json` ([#320](https://github.com/a2aproject/a2a-python/issues/320)) ([270ea9b](https://github.com/a2aproject/a2a-python/commit/270ea9b0822b689e50ed12f745a24a17e7917e73))
+
+## [0.2.16](https://github.com/a2aproject/a2a-python/compare/v0.2.15...v0.2.16) (2025-07-21)
+
+
+### Features
+
+* Convert fields in `types.py` to use `snake_case` ([#199](https://github.com/a2aproject/a2a-python/issues/199)) ([0bb5563](https://github.com/a2aproject/a2a-python/commit/0bb55633272605a0404fc14c448a9dcaca7bb693))
+
+
+### Bug Fixes
+
+* Add deprecation warning for camelCase alias ([#334](https://github.com/a2aproject/a2a-python/issues/334)) ([f22b384](https://github.com/a2aproject/a2a-python/commit/f22b384d919e349be8d275c8f44bd760d627bcb9))
+* client should not specify `taskId` if it doesn't exist ([#264](https://github.com/a2aproject/a2a-python/issues/264)) ([97f1093](https://github.com/a2aproject/a2a-python/commit/97f109326c7fe291c96bb51935ac80e0fab4cf66))
+
+## [0.2.15](https://github.com/a2aproject/a2a-python/compare/v0.2.14...v0.2.15) (2025-07-21)
+
+
+### Bug Fixes
+
+* Add Input Validation for Empty Message Content ([#327](https://github.com/a2aproject/a2a-python/issues/327)) ([5061834](https://github.com/a2aproject/a2a-python/commit/5061834e112a4eb523ac505f9176fc42d86d8178))
+* Prevent import grpc issues for Client after making dependencies optional ([#330](https://github.com/a2aproject/a2a-python/issues/330)) ([53ad485](https://github.com/a2aproject/a2a-python/commit/53ad48530b47ef1cbd3f40d0432f9170b663839d)), closes [#326](https://github.com/a2aproject/a2a-python/issues/326)
+
+## [0.2.14](https://github.com/a2aproject/a2a-python/compare/v0.2.13...v0.2.14) (2025-07-18)
+
+
+### Features
+
+* Set grpc dependencies as optional ([#322](https://github.com/a2aproject/a2a-python/issues/322)) ([365f158](https://github.com/a2aproject/a2a-python/commit/365f158f87166838b55bdadd48778cb313a453e1))
+* **spec:** Update A2A types from specification 🤖 ([#325](https://github.com/a2aproject/a2a-python/issues/325)) ([02e7a31](https://github.com/a2aproject/a2a-python/commit/02e7a3100e000e115b4aeec7147cf8fc1948c107))
+
+## [0.2.13](https://github.com/a2aproject/a2a-python/compare/v0.2.12...v0.2.13) (2025-07-17)
+
+
+### Features
+
+* Add `get_data_parts()` and `get_file_parts()` helper methods ([#312](https://github.com/a2aproject/a2a-python/issues/312)) ([5b98c32](https://github.com/a2aproject/a2a-python/commit/5b98c3240db4ff6007e242742f76822fc6ea380c))
+* Support for Database based Push Config Store ([#299](https://github.com/a2aproject/a2a-python/issues/299)) ([e5d99ee](https://github.com/a2aproject/a2a-python/commit/e5d99ee9e478cda5e93355cba2e93f1d28039806))
+* Update A2A types from specification 🤖 ([#319](https://github.com/a2aproject/a2a-python/issues/319)) ([18506a4](https://github.com/a2aproject/a2a-python/commit/18506a4fe32c1956725d8f205ec7848f7b86c77d))
+
+
+### Bug Fixes
+
+* Add Input Validation for Task IDs in TaskManager ([#310](https://github.com/a2aproject/a2a-python/issues/310)) ([a38d438](https://github.com/a2aproject/a2a-python/commit/a38d43881d8476e6fbcb9766b59e3378dbe64306))
+* Add validation for empty artifact lists in `completed_task` ([#308](https://github.com/a2aproject/a2a-python/issues/308)) ([c4a324d](https://github.com/a2aproject/a2a-python/commit/c4a324dcb693f19fbbf90cee483f6a912698a921))
+* Handle readtimeout errors. ([#305](https://github.com/a2aproject/a2a-python/issues/305)) ([b94b8f5](https://github.com/a2aproject/a2a-python/commit/b94b8f52bf58315f3ef138b6a1ffaf894f35bcef)), closes [#249](https://github.com/a2aproject/a2a-python/issues/249)
+
+
+### Documentation
+
+* Update Documentation Site Link ([#315](https://github.com/a2aproject/a2a-python/issues/315)) ([edf392c](https://github.com/a2aproject/a2a-python/commit/edf392cfe531d0448659e2f08ab08f0ba05475b3))
+
+## [0.2.12](https://github.com/a2aproject/a2a-python/compare/v0.2.11...v0.2.12) (2025-07-14)
+
+
+### Features
+
+* add `metadata` property to `RequestContext` ([#302](https://github.com/a2aproject/a2a-python/issues/302)) ([e781ced](https://github.com/a2aproject/a2a-python/commit/e781ced3b082ef085f9aeef02ceebb9b35c68280))
+* add A2ABaseModel ([#292](https://github.com/a2aproject/a2a-python/issues/292)) ([24f2eb0](https://github.com/a2aproject/a2a-python/commit/24f2eb0947112539cbd4e493c98d0d9dadc87f05))
+* add support for notification tokens in PushNotificationSender ([#266](https://github.com/a2aproject/a2a-python/issues/266)) ([75aa4ed](https://github.com/a2aproject/a2a-python/commit/75aa4ed866a6b4005e59eb000e965fb593e0888f))
+* Update A2A types from specification 🤖 ([#289](https://github.com/a2aproject/a2a-python/issues/289)) ([ecb321a](https://github.com/a2aproject/a2a-python/commit/ecb321a354d691ca90b52cc39e0a397a576fd7d7))
+
+
+### Bug Fixes
+
+* add proper a2a request body documentation to Swagger UI ([#276](https://github.com/a2aproject/a2a-python/issues/276)) ([4343be9](https://github.com/a2aproject/a2a-python/commit/4343be99ad0df5eb6908867b71d55b1f7d0fafc6)), closes [#274](https://github.com/a2aproject/a2a-python/issues/274)
+* Handle asyncio.cancellederror and raise to propagate back ([#293](https://github.com/a2aproject/a2a-python/issues/293)) ([9d6cb68](https://github.com/a2aproject/a2a-python/commit/9d6cb68a1619960b9c9fd8e7aa08ffb27047343f))
+* Improve error handling in task creation ([#294](https://github.com/a2aproject/a2a-python/issues/294)) ([6412c75](https://github.com/a2aproject/a2a-python/commit/6412c75413e26489bd3d33f59e41b626a71807d3))
+* Resolve dependency issue with sql stores ([#303](https://github.com/a2aproject/a2a-python/issues/303)) ([2126828](https://github.com/a2aproject/a2a-python/commit/2126828b5cb6291f47ca15d56c0e870950f17536))
+* Send push notifications for message/send ([#298](https://github.com/a2aproject/a2a-python/issues/298)) ([0274112](https://github.com/a2aproject/a2a-python/commit/0274112bb5b077c17b344da3a65277f2ad67d38f))
+* **server:** Improve event consumer error handling ([#282](https://github.com/a2aproject/a2a-python/issues/282)) ([a5786a1](https://github.com/a2aproject/a2a-python/commit/a5786a112779a21819d28e4dfee40fa11f1bb49a))
+
+## [0.2.11](https://github.com/a2aproject/a2a-python/compare/v0.2.10...v0.2.11) (2025-07-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* Removes `push_notifier` interface from the SDK and introduces `push_notification_config_store` and `push_notification_sender` for supporting push notifications.
+
+### Features
+
+* Add constants for Well-Known URIs ([#271](https://github.com/a2aproject/a2a-python/issues/271)) ([1c8e12e](https://github.com/a2aproject/a2a-python/commit/1c8e12e448dc7469e508fccdac06818836f5b520))
+* Adds support for List and Delete push notification configurations. ([f1b576e](https://github.com/a2aproject/a2a-python/commit/f1b576e061e7a3ab891d8368ade56c7046684c5e))
+* Adds support for more than one `push_notification_config` per task. ([f1b576e](https://github.com/a2aproject/a2a-python/commit/f1b576e061e7a3ab891d8368ade56c7046684c5e))
+* **server:** Add lock to TaskUpdater to prevent race conditions ([#279](https://github.com/a2aproject/a2a-python/issues/279)) ([1022093](https://github.com/a2aproject/a2a-python/commit/1022093110100da27f040be4b35831bf8b1fe094))
+* Support for database backend Task Store ([#259](https://github.com/a2aproject/a2a-python/issues/259)) ([7c46e70](https://github.com/a2aproject/a2a-python/commit/7c46e70b3142f3ec274c492bacbfd6e8f0204b36))
+
+
+### Code Refactoring
+
+* Removes `push_notifier` interface from the SDK and introduces `push_notification_config_store` and `push_notification_sender` for supporting push notifications. ([f1b576e](https://github.com/a2aproject/a2a-python/commit/f1b576e061e7a3ab891d8368ade56c7046684c5e))
+
+## [0.2.10](https://github.com/a2aproject/a2a-python/compare/v0.2.9...v0.2.10) (2025-06-30)
+
+
+### ⚠ BREAKING CHANGES
+
+* Update to A2A Spec Version [0.2.5](https://github.com/a2aproject/A2A/releases/tag/v0.2.5) ([#197](https://github.com/a2aproject/a2a-python/issues/197))
+
+### Features
+
+* Add `append` and `last_chunk` to `add_artifact` method on `TaskUpdater` ([#186](https://github.com/a2aproject/a2a-python/issues/186)) ([8c6560f](https://github.com/a2aproject/a2a-python/commit/8c6560fd403887fab9d774bfcc923a5f6f459364))
+* add a2a routes to existing app ([#188](https://github.com/a2aproject/a2a-python/issues/188)) ([32fecc7](https://github.com/a2aproject/a2a-python/commit/32fecc7194a61c2f5be0b8795d5dc17cdbab9040))
+* Add middleware to the client SDK ([#171](https://github.com/a2aproject/a2a-python/issues/171)) ([efaabd3](https://github.com/a2aproject/a2a-python/commit/efaabd3b71054142109b553c984da1d6e171db24))
+* Add more task state management methods to TaskUpdater ([#208](https://github.com/a2aproject/a2a-python/issues/208)) ([2b3bf6d](https://github.com/a2aproject/a2a-python/commit/2b3bf6d53ac37ed93fc1b1c012d59c19060be000))
+* raise error for tasks in terminal states ([#215](https://github.com/a2aproject/a2a-python/issues/215)) ([a0bf13b](https://github.com/a2aproject/a2a-python/commit/a0bf13b208c90b439b4be1952c685e702c4917a0))
+
+### Bug Fixes
+
+* `consume_all` doesn't catch `asyncio.TimeoutError` in python 3.10 ([#216](https://github.com/a2aproject/a2a-python/issues/216)) ([39307f1](https://github.com/a2aproject/a2a-python/commit/39307f15a1bb70eb77aee2211da038f403571242))
+* Append metadata and context id when processing TaskStatusUpdateE… ([#238](https://github.com/a2aproject/a2a-python/issues/238)) ([e106020](https://github.com/a2aproject/a2a-python/commit/e10602033fdd4f4e6b61af717ffc242d772545b3))
+* Fix reference to `grpc.aio.ServicerContext` ([#237](https://github.com/a2aproject/a2a-python/issues/237)) ([0c1987b](https://github.com/a2aproject/a2a-python/commit/0c1987bb85f3e21089789ee260a0c62ac98b66a5))
+* Fixes Short Circuit clause for context ID ([#236](https://github.com/a2aproject/a2a-python/issues/236)) ([a5509e6](https://github.com/a2aproject/a2a-python/commit/a5509e6b37701dfb5c729ccc12531e644a12f8ae))
+* Resolve `APIKeySecurityScheme` parsing failed ([#226](https://github.com/a2aproject/a2a-python/issues/226)) ([aa63b98](https://github.com/a2aproject/a2a-python/commit/aa63b982edc2a07fd0df0b01fb9ad18d30b35a79))
+* send notifications on message not streaming ([#219](https://github.com/a2aproject/a2a-python/issues/219)) ([91539d6](https://github.com/a2aproject/a2a-python/commit/91539d69e5c757712c73a41ab95f1ec6656ef5cd)), closes [#218](https://github.com/a2aproject/a2a-python/issues/218)
+
+## [0.2.9](https://github.com/a2aproject/a2a-python/compare/v0.2.8...v0.2.9) (2025-06-24)
+
+### Bug Fixes
+
+* Set `protobuf==5.29.5` and `fastapi>=0.115.2` to prevent version conflicts ([#224](https://github.com/a2aproject/a2a-python/issues/224)) ([1412a85](https://github.com/a2aproject/a2a-python/commit/1412a855b4980d8373ed1cea38c326be74069633))
+
+## [0.2.8](https://github.com/a2aproject/a2a-python/compare/v0.2.7...v0.2.8) (2025-06-12)
+
+
+### Features
+
+* Add HTTP Headers to ServerCallContext for Improved Handler Access ([#182](https://github.com/a2aproject/a2a-python/issues/182)) ([d5e5f5f](https://github.com/a2aproject/a2a-python/commit/d5e5f5f7e7a3cab7de13cff545a874fc58d85e46))
+* Update A2A types from specification 🤖 ([#191](https://github.com/a2aproject/a2a-python/issues/191)) ([174230b](https://github.com/a2aproject/a2a-python/commit/174230bf6dfb6bf287d233a101b98cc4c79cad19))
+
+
+### Bug Fixes
+
+* Add `protobuf==6.31.1` to dependencies ([#189](https://github.com/a2aproject/a2a-python/issues/189)) ([ae1c31c](https://github.com/a2aproject/a2a-python/commit/ae1c31c1da47f6965c02e0564dc7d3791dd03e2c)), closes [#185](https://github.com/a2aproject/a2a-python/issues/185)
+
+## [0.2.7](https://github.com/a2aproject/a2a-python/compare/v0.2.6...v0.2.7) (2025-06-11)
+
+
+### Features
+
+* Update A2A types from specification 🤖 ([#179](https://github.com/a2aproject/a2a-python/issues/179)) ([3ef4240](https://github.com/a2aproject/a2a-python/commit/3ef42405f6096281fe90b1df399731bd009bde12))
+
+## [0.2.6](https://github.com/a2aproject/a2a-python/compare/v0.2.5...v0.2.6) (2025-06-09)
+
+
+### ⚠ BREAKING CHANGES
+
+* Add FastAPI JSONRPC Application ([#104](https://github.com/a2aproject/a2a-python/issues/104))
+
+### Features
+
+* Add FastAPI JSONRPC Application ([#104](https://github.com/a2aproject/a2a-python/issues/104)) ([0e66e1f](https://github.com/a2aproject/a2a-python/commit/0e66e1f81f98d7e2cf50b1c100e35d13ad7149dc))
+* Add gRPC server and client support ([#162](https://github.com/a2aproject/a2a-python/issues/162)) ([a981605](https://github.com/a2aproject/a2a-python/commit/a981605dbb32e87bd241b64bf2e9bb52831514d1))
+* add reject method to task_updater ([#147](https://github.com/a2aproject/a2a-python/issues/147)) ([2a6ef10](https://github.com/a2aproject/a2a-python/commit/2a6ef109f8b743f8eb53d29090cdec7df143b0b4))
+* Add timestamp to `TaskStatus` updates on `TaskUpdater` ([#140](https://github.com/a2aproject/a2a-python/issues/140)) ([0c9df12](https://github.com/a2aproject/a2a-python/commit/0c9df125b740b947b0e4001421256491b5f87920))
+* **spec:** Add an optional iconUrl field to the AgentCard 🤖 ([a1025f4](https://github.com/a2aproject/a2a-python/commit/a1025f406acd88e7485a5c0f4dd8a42488c41fa2))
+
+
+### Bug Fixes
+
+* Correctly adapt starlette BaseUser to A2A User ([#133](https://github.com/a2aproject/a2a-python/issues/133)) ([88d45eb](https://github.com/a2aproject/a2a-python/commit/88d45ebd935724e6c3ad614bf503defae4de5d85))
+* Event consumer should stop on input_required ([#167](https://github.com/a2aproject/a2a-python/issues/167)) ([51c2d8a](https://github.com/a2aproject/a2a-python/commit/51c2d8addf9e89a86a6834e16deb9f4ac0e05cc3))
+* Fix Release Version ([#161](https://github.com/a2aproject/a2a-python/issues/161)) ([011d632](https://github.com/a2aproject/a2a-python/commit/011d632b27b201193813ce24cf25e28d1335d18e))
+* generate StrEnum types for enums ([#134](https://github.com/a2aproject/a2a-python/issues/134)) ([0c49dab](https://github.com/a2aproject/a2a-python/commit/0c49dabcdb9d62de49fda53d7ce5c691b8c1591c))
+* library should be released as 0.2.6 ([d8187e8](https://github.com/a2aproject/a2a-python/commit/d8187e812d6ac01caedf61d4edaca522e583d7da))
+* remove error types from enqueueable events ([#138](https://github.com/a2aproject/a2a-python/issues/138)) ([511992f](https://github.com/a2aproject/a2a-python/commit/511992fe585bd15e956921daeab4046dc4a50a0a))
+* **stream:** don't block event loop in EventQueue ([#151](https://github.com/a2aproject/a2a-python/issues/151)) ([efd9080](https://github.com/a2aproject/a2a-python/commit/efd9080b917c51d6e945572fd123b07f20974a64))
+* **task_updater:** fix potential duplicate artifact_id from default v… ([#156](https://github.com/a2aproject/a2a-python/issues/156)) ([1f0a769](https://github.com/a2aproject/a2a-python/commit/1f0a769c1027797b2f252e4c894352f9f78257ca))
+
+
+### Documentation
+
+* remove final and metadata fields from docstring ([#66](https://github.com/a2aproject/a2a-python/issues/66)) ([3c50ee1](https://github.com/a2aproject/a2a-python/commit/3c50ee1f64c103a543c8afb6d2ac3a11063b0f43))
+* Update Links to Documentation Site ([5e7d418](https://github.com/a2aproject/a2a-python/commit/5e7d4180f7ae0ebeb76d976caa5ef68b4277ce54))
+
+## [0.2.5](https://github.com/a2aproject/a2a-python/compare/v0.2.4...v0.2.5) (2025-05-27)
+
+
+### Features
+
+* Add a User representation to ServerCallContext ([#116](https://github.com/a2aproject/a2a-python/issues/116)) ([2cc2a0d](https://github.com/a2aproject/a2a-python/commit/2cc2a0de93631aa162823d43fe488173ed8754dc))
+* Add functionality for extended agent card.  ([#31](https://github.com/a2aproject/a2a-python/issues/31)) ([20f0826](https://github.com/a2aproject/a2a-python/commit/20f0826a2cb9b77b89b85189fd91e7cd62318a30))
+* Introduce a ServerCallContext ([#94](https://github.com/a2aproject/a2a-python/issues/94)) ([85b521d](https://github.com/a2aproject/a2a-python/commit/85b521d8a790dacb775ef764a66fbdd57b180da3))
+
+
+### Bug Fixes
+
+* fix hello world example for python 3.12 ([#98](https://github.com/a2aproject/a2a-python/issues/98)) ([536e4a1](https://github.com/a2aproject/a2a-python/commit/536e4a11f2f32332968a06e7d0bc4615e047a56c))
+* Remove unused dependencies and update py version ([#119](https://github.com/a2aproject/a2a-python/issues/119)) ([9f8bc02](https://github.com/a2aproject/a2a-python/commit/9f8bc023b45544942583818968f3d320e5ff1c3b))
+* Update hello world test client to match sdk behavior. Also down-level required python version ([#117](https://github.com/a2aproject/a2a-python/issues/117)) ([04c7c45](https://github.com/a2aproject/a2a-python/commit/04c7c452f5001d69524d94095d11971c1e857f75))
+* Update the google adk demos to use ADK v1.0 ([#95](https://github.com/a2aproject/a2a-python/issues/95)) ([c351656](https://github.com/a2aproject/a2a-python/commit/c351656a91c37338668b0cd0c4db5fedd152d743))
+
+
+### Documentation
+
+* Update README for Python 3.10+ support ([#90](https://github.com/a2aproject/a2a-python/issues/90)) ([e0db20f](https://github.com/a2aproject/a2a-python/commit/e0db20ffc20aa09ee68304cc7e2a67c32ecdd6a8))
+
+## [0.2.4](https://github.com/a2aproject/a2a-python/compare/v0.2.3...v0.2.4) (2025-05-22)
+
+### Features
+
+* Update to support python 3.10 ([#85](https://github.com/a2aproject/a2a-python/issues/85)) ([fd9c3b5](https://github.com/a2aproject/a2a-python/commit/fd9c3b5b0bbef509789a701171d95f690c84750b))
+
+
+### Bug Fixes
+
+* Throw exception for task_id mismatches ([#70](https://github.com/a2aproject/a2a-python/issues/70)) ([a9781b5](https://github.com/a2aproject/a2a-python/commit/a9781b589075280bfaaab5742d8b950916c9de74))
+
+## [0.2.3](https://github.com/a2aproject/a2a-python/compare/v0.2.2...v0.2.3) (2025-05-20)
+
+
+### Features
+
+* Add request context builder with referenceTasks ([#56](https://github.com/a2aproject/a2a-python/issues/56)) ([f20bfe7](https://github.com/a2aproject/a2a-python/commit/f20bfe74b8cc854c9c29720b2ea3859aff8f509e))
+
+## [0.2.2](https://github.com/a2aproject/a2a-python/compare/v0.2.1...v0.2.2) (2025-05-20)
+
+
+### Documentation
+
+* Write/Update Docstrings for Classes/Methods ([#59](https://github.com/a2aproject/a2a-python/issues/59)) ([9f773ef](https://github.com/a2aproject/a2a-python/commit/9f773eff4dddc4eec723d519d0050f21b9ccc042))
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 9feb80f71..3ef339257 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -47,7 +47,7 @@ offensive, or harmful.
 
 This Code of Conduct applies both within project spaces and in public spaces
 when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
+representing a project or community include using an official project email
 address, posting via an official social media account, or acting as an appointed
 representative at an online or offline event. Representation of a project may be
 further defined and clarified by project maintainers.
@@ -93,4 +93,4 @@ available at
 https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
 
 Note: A version of this file is also available in the
-[New Project repo](https://github.com/google/new-project/blob/master/docs/code-of-conduct.md).
+[New Project repository](https://github.com/google/new-project/blob/main/docs/code-of-conduct.md).
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 289176c74..40d511cd2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,27 +2,6 @@
 
 We'd love to accept your patches and contributions to this project.
 
-## Before you begin
-
-### Sign our Contributor License Agreement
-
-Contributions to this project must be accompanied by a
-[Contributor License Agreement](https://cla.developers.google.com/about) (CLA).
-You (or your employer) retain the copyright to your contribution; this simply
-gives us permission to use and redistribute your contributions as part of the
-project.
-
-If you or your current employer have already signed the Google CLA (even if it
-was for a different project), you probably don't need to do it again.
-
-Visit <https://cla.developers.google.com/> to see your current agreements or to
-sign a new one.
-
-### Review our community guidelines
-
-This project follows
-[Google's Open Source Community Guidelines](https://opensource.google/conduct/).
-
 ## Contribution process
 
 ### Code reviews
@@ -47,11 +26,3 @@ Here are some additional things to keep in mind during the process:
 
 - **Test your changes.** Before you submit a pull request, make sure that your changes work as expected.
 - **Be patient.** It may take some time for your pull request to be reviewed and merged.
-
----
-
-## For Google Employees
-
-Complete the following steps to register your GitHub account and be added as a contributor to this repository.
-
-1. Register your GitHub account at [go/GitHub](http://go/github).
diff --git a/README.md b/README.md
index 0a3f546b0..303e73400 100644
--- a/README.md
+++ b/README.md
@@ -1,38 +1,123 @@
-# A2A SDK (Prototype)
+# A2A Python SDK
 
-Early version of the A2A Python SDK.
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
+[![PyPI version](https://img.shields.io/pypi/v/a2a-sdk)](https://pypi.org/project/a2a-sdk/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/a2a-sdk)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/a2a-sdk)](https://pypistats.org/packages/a2a-sdk)
+[![Python Unit Tests](https://github.com/a2aproject/a2a-python/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/a2aproject/a2a-python/actions/workflows/unit-tests.yml)
+<!-- markdownlint-disable no-inline-html -->
+<a href="https://codewiki.google/github.com/a2aproject/a2a-python">
+  <img src="https://www.gstatic.com/_/boq-sdlc-agents-ui/_/r/Mvosg4klCA4.svg" alt="Ask Code Wiki" height="20">
+</a>
 
-## Install SDK
+<div align="center">
+   <img src="https://raw.githubusercontent.com/a2aproject/A2A/refs/heads/main/docs/assets/a2a_logo/color/SVG/a2a_color.svg" width="800" alt="Agent2Agent Protocol Logo"/>
+   <h3>
+      A Python library for running agentic applications as A2A Servers, following the <a href="https://a2a-protocol.org">Agent2Agent (A2A) Protocol</a>.
+   </h3>
+</div>
 
-```bash
-pip install .
-```
+<!-- markdownlint-enable no-inline-html -->
 
-## Verify install
+---
 
-```py
-import a2a
-```
+> [!IMPORTANT]
+> **Upgrading the SDK from `0.3` to `1.0`?** See the [**v0.3 → v1.0 migration guide**](docs/migrations/v1_0/README.md). For supported A2A spec versions, see [Compatibility](#-compatibility).
 
-## Run Helloworld
 
-Run Remote Agent
+## ✨ Features
 
-```bash
-cd examples/helloworld
-python __main__.py
-```
+- **A2A Protocol Compliant:** Build agentic applications that adhere to the Agent2Agent (A2A) Protocol.
+- **Extensible:** Easily add support for different communication protocols and database backends.
+- **Asynchronous:** Built on modern async Python for high performance.
+- **Optional Integrations:** Includes optional support for:
+  - HTTP servers ([FastAPI](https://fastapi.tiangolo.com/), [Starlette](https://www.starlette.io/))
+  - [gRPC](https://grpc.io/)
+  - [OpenTelemetry](https://opentelemetry.io/) for tracing
+  - SQL databases ([PostgreSQL](https://www.postgresql.org/), [MySQL](https://www.mysql.com/), [SQLite](https://sqlite.org/))
 
-In another terminal, run the client
+---
 
-```bash
-python test_client.py
-```
+## 🧩 Compatibility
 
-## License
+This SDK implements the A2A Protocol Specification [`1.0`](https://a2a-protocol.org/v1.0.0/specification/), with compatibility mode for [`0.3`](https://a2a-protocol.org/v0.3.0/specification). See [#742](https://github.com/a2aproject/a2a-python/issues/742) for details on the compatibility scope.
 
-This project is licensed under the terms of the [Apache 2.0 License](LICENSE).
+| Spec Version | Transport | Client | Server |
+| :--- | :--- | :---: | :---: |
+| **`1.0`** | JSON-RPC | ✅ | ✅ |
+| **`1.0`** | HTTP+JSON/REST | ✅ | ✅ |
+| **`1.0`** | gRPC | ✅ | ✅ |
+| **`0.3`** (compat) | JSON-RPC | ✅ | ✅ |
+| **`0.3`** (compat) | HTTP+JSON/REST | ✅ | ✅ |
+| **`0.3`** (compat) | gRPC | ✅ | ✅ |
 
-## Contributing
+---
 
-See [CONTRIBUTING.md](../CONTRIBUTING.md) for contribution guidelines.
+## 🚀 Getting Started
+
+### Prerequisites
+
+- Python 3.10+
+- `uv` (recommended) or `pip`
+
+### 🔧 Installation
+
+Install the core SDK and any desired extras using your preferred package manager.
+
+| Feature                  | `uv` Command                               | `pip` Command                                |
+| ------------------------ | ------------------------------------------ | -------------------------------------------- |
+| **Core SDK**             | `uv add a2a-sdk`                           | `pip install a2a-sdk`                        |
+| **All Extras**           | `uv add "a2a-sdk[all]"`                    | `pip install "a2a-sdk[all]"`                 |
+| **HTTP Server**          | `uv add "a2a-sdk[http-server]"`            | `pip install "a2a-sdk[http-server]"`         |
+| **FastAPI Integration**  | `uv add "a2a-sdk[fastapi]"`                | `pip install "a2a-sdk[fastapi]"`             |
+| **gRPC Support**         | `uv add "a2a-sdk[grpc]"`                   | `pip install "a2a-sdk[grpc]"`                |
+| **OpenTelemetry Tracing**| `uv add "a2a-sdk[telemetry]"`              | `pip install "a2a-sdk[telemetry]"`           |
+| **Encryption**           | `uv add "a2a-sdk[encryption]"`             | `pip install "a2a-sdk[encryption]"`          |
+|                          |                                            |                                              |
+| **Database Drivers**     |                                            |                                              |
+| **PostgreSQL**           | `uv add "a2a-sdk[postgresql]"`             | `pip install "a2a-sdk[postgresql]"`          |
+| **MySQL**                | `uv add "a2a-sdk[mysql]"`                  | `pip install "a2a-sdk[mysql]"`               |
+| **SQLite**               | `uv add "a2a-sdk[sqlite]"`                 | `pip install "a2a-sdk[sqlite]"`              |
+| **All SQL Drivers**      | `uv add "a2a-sdk[sql]"`                    | `pip install "a2a-sdk[sql]"`                 |
+
+## Examples
+
+### [Helloworld Example](https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/helloworld)
+
+1. Run Remote Agent
+
+   ```bash
+   git clone https://github.com/a2aproject/a2a-samples.git
+   cd a2a-samples/samples/python/agents/helloworld
+   uv run .
+   ```
+
+2. In another terminal, run the client
+
+   ```bash
+   cd a2a-samples/samples/python/agents/helloworld
+   uv run test_client.py
+   ```
+
+3. You can validate your agent using the agent inspector. Follow the instructions at the [a2a-inspector](https://github.com/a2aproject/a2a-inspector) repo.
+
+---
+
+## 🌐 More Examples
+
+You can find a variety of more detailed examples in the [a2a-samples](https://github.com/a2aproject/a2a-samples) repository:
+
+- **[Python Examples](https://github.com/a2aproject/a2a-samples/tree/main/samples/python)**
+- **[JavaScript Examples](https://github.com/a2aproject/a2a-samples/tree/main/samples/js)**
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) file for guidelines on how to get involved.
+
+---
+
+## 📄 License
+
+This project is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for more details.
diff --git a/SECURITY.md b/SECURITY.md
index 8b58ae9c0..2096d91f6 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,7 +1,6 @@
 # Security Policy
 
-To report a security issue, please use [g.co/vulnz](https://g.co/vulnz).
+To report a security issue, please use GitHub Security Advisories:
+[Security Advisories · a2aproject/a2a-python](https://github.com/a2aproject/a2a-python/security/advisories)
 
-The Google Security Team will respond within 5 working days of your report on g.co/vulnz.
-
-We use g.co/vulnz for our intake, and do coordination and disclosure here using GitHub Security Advisory to privately discuss and fix the issue.
+We use GitHub Security Advisories for private intake, coordination, and disclosure.
diff --git a/acts/sut-behaviors.yaml b/acts/sut-behaviors.yaml
new file mode 100644
index 000000000..15971b9ea
--- /dev/null
+++ b/acts/sut-behaviors.yaml
@@ -0,0 +1,106 @@
+# Which ACTS `tck-*` behaviours this SDK's ITK agent implements (ACTS §11.1).
+#
+# **This file is the list.** `itk/acts_behaviors.py` implements the behaviours
+# but does not restate their names, so there is nothing here to drift out of
+# step with — the two are a claim and its implementation, and the runner checks
+# one against the other by running the tests.
+#
+# A prefix listed here but not implemented makes the test FAIL, not skip:
+# deliberately, so lagging support stays visible in the conformance report
+# instead of quietly shrinking it. Adding a behaviour means adding a branch in
+# `_dispatch` and an entry here.
+
+acts_version: "1.0"
+
+behaviors:
+  - prefix: "tck-complete-task"
+    description: "Complete the task with a text response message"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+
+  - prefix: "tck-input-required"
+    description: "Return the task in INPUT_REQUIRED"
+    response_type: task
+    terminal_state: TASK_STATE_INPUT_REQUIRED
+
+  - prefix: "tck-auth-required"
+    description: "Return the task in AUTH_REQUIRED"
+    response_type: task
+    terminal_state: TASK_STATE_AUTH_REQUIRED
+
+  - prefix: "tck-reject-task"
+    description: "Reject the task"
+    response_type: task
+    terminal_state: TASK_STATE_REJECTED
+
+  - prefix: "tck-task-failure"
+    description: "Complete with FAILED and an error message"
+    response_type: task
+    terminal_state: TASK_STATE_FAILED
+
+  - prefix: "tck-message-response"
+    description: "Return a direct Message, not a Task"
+    response_type: message
+
+  - prefix: "tck-multi-turn"
+    description: "Stay in INPUT_REQUIRED until the user sends 'done'"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+
+  - prefix: "tck-cancel"
+    description: "Remain in WORKING until canceled"
+    response_type: task
+    terminal_state: TASK_STATE_CANCELED
+
+  - prefix: "tck-long-running"
+    description: "Stay in WORKING briefly, then complete"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    delay_ms: 1000
+
+  - prefix: "tck-artifact-text"
+    description: "Complete with a text artifact"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    artifacts:
+      - text: "generated text content"
+
+  - prefix: "tck-artifact-data"
+    description: "Complete with a structured data artifact"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    artifacts:
+      - data: {key: "value", count: 1}
+
+  - prefix: "tck-artifact-file"
+    description: "Complete with a file artifact carrying inline bytes"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    artifacts:
+      - file: {name: "document.txt", mediaType: "text/plain"}
+
+  - prefix: "tck-artifact-file-url"
+    description: "Complete with a file artifact carrying a URL"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    artifacts:
+      - fileUrl:
+          url: "https://example.com/document.txt"
+          name: "document.txt"
+          mediaType: "text/plain"
+
+  - prefix: "tck-stream-basic"
+    description: "Stream working -> artifact -> completed"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    streaming: true
+    artifacts:
+      - text: "streamed content"
+
+  - prefix: "tck-stream-chunked"
+    description: "Stream one artifact across several appended chunks"
+    response_type: task
+    terminal_state: TASK_STATE_COMPLETED
+    streaming: true
+    artifacts:
+      - text: "chunk one chunk two chunk three"
diff --git a/buf.compat.gen.yaml b/buf.compat.gen.yaml
new file mode 100644
index 000000000..759cad2dd
--- /dev/null
+++ b/buf.compat.gen.yaml
@@ -0,0 +1,12 @@
+# Protobuf generation for legacy v0.3 A2A protocol buffer modules.
+---
+version: v2
+managed:
+  enabled: true
+plugins:
+  - remote: buf.build/protocolbuffers/python:v29.3
+    out: src/a2a/compat/v0_3
+  - remote: buf.build/grpc/python
+    out: src/a2a/compat/v0_3
+  - remote: buf.build/protocolbuffers/pyi
+    out: src/a2a/compat/v0_3
diff --git a/buf.gen.yaml b/buf.gen.yaml
new file mode 100644
index 000000000..d7937469c
--- /dev/null
+++ b/buf.gen.yaml
@@ -0,0 +1,31 @@
+---
+version: v2
+inputs:
+  - git_repo: https://github.com/a2aproject/A2A.git
+    ref: v1.0.0
+    subdir: specification
+managed:
+  enabled: true
+# Python Generation
+# Using remote plugins. To use local plugins replace remote with local
+# pip install protobuf grpcio-tools
+# Optionally, install plugin to generate stubs for grpc services
+# pip install mypy-protobuf
+# Generate python protobuf code
+# - local: protoc-gen-python
+# - out: src/python
+# Generate gRPC stubs
+# - local: protoc-gen-grpc-python
+# - out: src/python
+plugins:
+  # Generate python protobuf related code
+  # Generates *_pb2.py files, one for each .proto
+  - remote: buf.build/protocolbuffers/python:v29.3
+    out: src/a2a/types
+  # Generate python service code.
+  # Generates *_pb2_grpc.py
+  - remote: buf.build/grpc/python
+    out: src/a2a/types
+  # Generates *_pb2.pyi files.
+  - remote: buf.build/protocolbuffers/pyi
+    out: src/a2a/types
diff --git a/docs/ai/coding_conventions.md b/docs/ai/coding_conventions.md
new file mode 100644
index 000000000..423310f3d
--- /dev/null
+++ b/docs/ai/coding_conventions.md
@@ -0,0 +1,21 @@
+### Coding Conventions & Style Guide
+
+Non-negotiable rules for code quality and style.
+
+1. **Python Types**: All Python code MUST include type hints. All function definitions MUST include return types.
+2. **Type Safety**: All code MUST pass `ty` checks.
+3. **Formatting & Linting**: All code MUST be formatted with `ruff`.
+
+#### Examples:
+
+**Correct Typing:**
+```python
+async def get_task_status(task: Task) -> TaskStatus:
+    return task.status
+```
+
+**Incorrect (Do NOT do this):**
+```python
+async def get_task_status(task): # Missing type hints for argument and return value
+    return task.status
+```
diff --git a/docs/ai/evidence_rules.md b/docs/ai/evidence_rules.md
new file mode 100644
index 000000000..5da67b13a
--- /dev/null
+++ b/docs/ai/evidence_rules.md
@@ -0,0 +1,24 @@
+# Evidence Rules
+
+Rules for what counts as adequate evidence when making claims about
+this codebase. These are graduated learnings — promoted from
+`docs/ai/ai_learnings.md` (local journal) once a rule has earned a
+permanent home.
+
+When in doubt, the bar is: **a future agent reading your response
+should be able to verify the claim from the citations alone, without
+re-doing your investigation.**
+
+## Claims about runtime behavior
+
+Back any claim about how code behaves at runtime with a `file:line`
+reference from a tool call in the same response, or with a runnable
+demonstration.
+
+The citation must support the specific claim. The *existence* of code
+is not evidence of its *behavior*: a function being defined doesn't
+mean it's called; an exception being raised doesn't mean it
+propagates; a parameter being declared doesn't mean it's honored; a
+config option existing doesn't mean it takes effect. Behavior claims
+require control-flow evidence (call chain, test output, log) — not
+just a definition site.
diff --git a/docs/ai/mandatory_checks.md b/docs/ai/mandatory_checks.md
new file mode 100644
index 000000000..5595d4011
--- /dev/null
+++ b/docs/ai/mandatory_checks.md
@@ -0,0 +1,14 @@
+# Mandatory Checks
+
+Run in this order before declaring any task done — including for
+markdown/comment/whitespace-only changes:
+
+```bash
+./scripts/lint.sh        # ruff check --fix, ruff format, ty check
+uv run pytest
+
+# Only before commit, when src/ changed:
+uv run pytest --cov=src --cov-report=term-missing
+```
+
+CI enforces `--cov-fail-under=88` on the `a2a` package.
diff --git a/docs/migrations/v1_0/README.md b/docs/migrations/v1_0/README.md
new file mode 100644
index 000000000..a1af8e7e4
--- /dev/null
+++ b/docs/migrations/v1_0/README.md
@@ -0,0 +1,688 @@
+# A2A Python SDK Migration Guide: v0.3 → v1.0
+
+The `a2a-sdk` has achieved a major milestone in stability and reliability with the update to full **A2A Protocol v1.0 compatibility**. This guide provides a detailed overview of the breaking changes in version `v1.0` and instructions for migrating your codebase.
+
+Beyond protocol support, `v1.0` enhances the developer experience by introducing unified helper utilities for easier object creation and adopting Starlette route factory functions for more flexible server configuration.
+
+This documentation details the technical upgrades and architectural modifications introduced in A2A Python SDK v1.0. For developers using the database persistence layer, please refer to the [Database Migration Guide](database/) for specific update instructions.
+
+> ### **Why Upgrade to v1.0?**
+> * **Protocol v1.0 Compliance**: Full alignment with the latest A2A industry standard for cross-agent interoperability.
+> * **Reduced Boilerplate**: Unified helper utilities that simplify common tasks like message and task creation.
+> * **Architectural Flexibility**: Direct Starlette/FastAPI integration allows you to mount A2A routes into existing applications with full control over middleware.
+
+---
+
+## Table of Contents
+
+1. [Update Dependencies](#1-update-dependencies)
+2. [Types](#2-types)
+3. [Server: DefaultRequestHandler](#3-server-defaultrequesthandler)
+4. [Server: AgentExecutor Streaming Rules](#4-server-agentexecutor-streaming-rules)
+5. [Server: Application Setup](#5-server-application-setup)
+6. [Supporting v0.3 Clients](#6-supporting-v03-clients)
+7. [Client: Creating a Client](#7-client-creating-a-client)
+8. [Client: Send Message](#8-client-send-message)
+9. [Client: Push Notifications Config](#9-client-push-notifications-config)
+10. [Helper Utilities](#10-helper-utilities)
+11. [Summary of Key Changes](#11-summary-of-key-changes-in-v10)
+12. [Get Started](#12-get-started)
+
+---
+
+## 1. Update Dependencies
+
+For UV users: To upgrade to the latest version of the `a2a-sdk`, update the dependencies section in your `pyproject.toml` file.
+
+| File             | Before (`v0.3`)                   | After (`v1.0`)                    |
+|------------------|-----------------------------------|-----------------------------------|
+| `pyproject.toml` | dependencies = ["a2a-sdk>=0.3.0"] | dependencies = ["a2a-sdk>=1.0.0"] |
+
+**Installation**
+
+After updating your configuration file, sync your environment:
+
+* Using UV:
+
+```bash
+uv sync
+```
+
+* Using pip:
+
+```bash
+pip install --upgrade a2a-sdk
+```
+
+---
+
+## 2. Types
+
+[Types](https://github.com/a2aproject/a2a-python/blob/main/src/a2a/types/a2a_pb2.pyi) have migrated from Pydantic models to Protobuf-based classes to align with the A2A spec's proto-first design and to adopt ProtoJSON as the canonical JSON serialization standard, ensuring consistent cross-implementation interoperability.
+
+
+### Enum values: `snake_case` → `SCREAMING_SNAKE_CASE`
+
+All enum values are now [standardized](https://a2a-protocol.org/v1.0.0/specification/#55-json-field-naming-convention) to use `SCREAMING_SNAKE_CASE` format.
+
+This affects every enum in the SDK: `TaskState`, `Role`.
+
+| Enum | v0.3 | v1.0 |
+|---|---|---|
+| `TaskState` | `TaskState.submitted` | `TaskState.TASK_STATE_SUBMITTED` |
+| `TaskState` | `TaskState.working` | `TaskState.TASK_STATE_WORKING` |
+| `TaskState` | `TaskState.completed` | `TaskState.TASK_STATE_COMPLETED` |
+| `TaskState` | `TaskState.failed` | `TaskState.TASK_STATE_FAILED` |
+| `TaskState` | `TaskState.canceled` | `TaskState.TASK_STATE_CANCELED` |
+| `TaskState` | `TaskState.input_required` | `TaskState.TASK_STATE_INPUT_REQUIRED` |
+| `TaskState` | `TaskState.auth_required` | `TaskState.TASK_STATE_AUTH_REQUIRED` |
+| `TaskState` | `TaskState.rejected` | `TaskState.TASK_STATE_REJECTED` |
+| `TaskState` | | 🆕 `TaskState.TASK_STATE_UNSPECIFIED` |
+|||
+| `Role` | `Role.user` | `Role.ROLE_USER` |
+| `Role` | `Role.agent` | `Role.ROLE_AGENT` |
+| `Role` | | 🆕 `Role.ROLE_UNSPECIFIED` |
+
+> **Example**: [`a2a-mcp-without-framework/server/agent_executor.py` in PR #509](https://github.com/a2aproject/a2a-samples/pull/509/changes#diff-1f9b098f9f82ee40666ee61db56dc2246281423c445bcf017079c53a0a05954f)
+
+### Message and Part construction
+
+Constructing messages is simplified in v1.0. The old API required wrapping content in an intermediate type (`TextPart`, `FilePart`, `DataPart`) before placing it inside a `Part`. In v1.0, the wrapper types are removed and all content fields are set directly on the unified `Part` message.
+
+| Part type | v0.3 | v1.0 |
+|---|---|---|
+| Text | `Part(TextPart(text=..., ...))` | `Part(text=..., ...)` |
+| File (bytes) | `Part(FilePart(file=FileWithBytes(bytes=..., ...)))` | `Part(raw=..., ...)` |
+| File (URI) | `Part(FilePart(file=FileWithUri(uri=..., ...)))` | `Part(url=..., ...)` |
+| Structured data | `Part(DataPart(data=..., ...))` | `Part(data=..., ...)` |
+
+**Note**:
+* When using `File (bytes)` in v1.0, data serialization (via base64 encoding) is not required because A2A now uses Protobuf, which handles it automatically.
+* In v1.0, `Part.DataPart.data` is renamed to `Part.data` and is of type `google.protobuf.Value`. Use `ParseDict` to convert a Python dict into a suitable value. See the examples below for more details.
+* `google.protobuf.Value` stores every number as a double, so whole numbers in a data Part are read back as floats on every transport (`4326` becomes `4326.0`). This is a fidelity loss, not a spec violation, since JSON does not distinguish the two. On the receiving side, narrow floats for fields you model as integers (for example with `float.is_integer()`) and leave other fields alone.
+
+**Before (v0.3):**
+```python
+import base64
+from uuid import uuid4
+from a2a.types import Message, Part, Role, TextPart, FilePart, DataPart, FileWithBytes, FileWithUri
+
+# Text part
+text_part = Part(TextPart(text="What's the weather in Warsaw?"))
+
+# File part — base64-encoded bytes (e.g. an image)
+with open("photo.png", "rb") as f:
+    image_b64 = base64.b64encode(f.read()).decode()
+file_bytes_part = Part(FilePart(file=FileWithBytes(
+    bytes=image_b64,
+    mime_type="image/png",
+    name="photo.png",
+)))
+
+# File part — URI pointing to a remote file
+file_uri_part = Part(FilePart(file=FileWithUri(
+    uri="https://example.com/report.pdf",
+    mime_type="application/pdf",
+    name="report.pdf",
+)))
+
+# Data part — structured JSON payload
+data_part = Part(DataPart(data={"city": "Warsaw", "temperature_c": 18}))
+
+message = Message(
+    role=Role.user,
+    parts=[text_part, file_bytes_part, file_uri_part, data_part],
+    message_id=uuid4().hex,
+    task_id=uuid4().hex,
+)
+```
+
+**After (v1.0):**
+
+```python
+from uuid import uuid4
+from google.protobuf.json_format import ParseDict
+from google.protobuf.struct_pb2 import Value
+from a2a.types import Message, Part, Role
+
+# Text part
+text_part = Part(text="What's the weather in Warsaw?")
+
+# File part — raw bytes (e.g. an image); no base64 encoding required
+with open("photo.png", "rb") as f:
+    image_bytes = f.read()
+file_bytes_part = Part(
+    raw=image_bytes,
+    media_type="image/png",
+    filename="photo.png",
+)
+
+# File part — URI pointing to a remote file
+file_uri_part = Part(
+    url="https://example.com/report.pdf",
+    media_type="application/pdf",
+    filename="report.pdf",
+)
+
+# Data part — use ParseDict to convert a Python dict to a protobuf Value
+data_part = Part(
+    data=ParseDict({"city": "Warsaw", "temperature_c": 18}, Value()),
+)
+
+message = Message(
+    role=Role.ROLE_USER,
+    parts=[text_part, file_bytes_part, file_uri_part, data_part],
+    message_id=uuid4().hex,
+    task_id=uuid4().hex,
+)
+```
+
+For text-only messages, use the [A2A helper utilities](#10-helper-utilities) to reduce boilerplate:
+
+```python
+from a2a.helpers import new_text_message
+from a2a.types import Role
+
+message = new_text_message(text="What's the weather in Warsaw?", role=Role.ROLE_USER)
+```
+
+> **Example**: [`helloworld/test_client.py` in PR #474](https://github.com/a2aproject/a2a-samples/pull/474/files#diff-f62c07d3b00364a3100b7effb3e2a1cca0624277d3e40da1bdb07bb46b6a8cef)
+
+### AgentCard Structure
+
+Key changes:
+- Added an `AgentInterface` class to support multiple transport bindings via the newly added `supported_interfaces` field in AgentCard.
+- The `url` parameter in `AgentCard` is removed and is now part of `AgentInterface`.
+- Accepted values for `AgentInterface.protocol_binding`: `'JSONRPC'`, `'HTTP+JSON'`, `'GRPC'`.
+- The `AgentCard.supports_authenticated_extended_card` field is renamed to `AgentCapabilities.extended_agent_card`.
+- The `AgentCapabilities.input_modes` and `AgentCapabilities.output_modes` fields are removed; use `AgentCard.default_input_modes` and `AgentCard.default_output_modes` for card-level defaults, or `AgentSkill.input_modes` and `AgentSkill.output_modes` for per-skill overrides.
+- The `examples` parameter in `AgentCard` is removed and is now part of `AgentSkill`.
+
+**Before (v0.3):**
+```python
+from a2a.types import AgentCard, AgentCapabilities, AgentSkill
+
+skill = AgentSkill(
+    id='hello_world',
+    name='Hello World',
+    description='Returns a Hello World message.',
+    tags=['hello', 'world'],
+    input_modes=['text/plain'],
+    output_modes=['text/plain'],
+    examples=['hello world'],
+)
+
+agent_card = AgentCard(
+    name='Hello World Agent',
+    description='Returns Hello, World!',
+    url='http://localhost:9999/',
+    version='0.0.1',
+    default_input_modes=['text/plain'],
+    default_output_modes=['text/plain'],
+    supports_authenticated_extended_card=True,
+    capabilities=AgentCapabilities(
+        input_modes=['text/plain'],
+        output_modes=['text/plain'],
+        streaming=True,
+    ),
+    skills=[skill],
+    examples=['Hello, World!'],
+)
+```
+
+**After (v1.0):**
+```python
+from a2a.types import AgentCard, AgentCapabilities, AgentInterface, AgentSkill
+
+skill = AgentSkill(
+    id='hello_world',
+    name='Hello World',
+    description='Returns a Hello World message.',
+    tags=['hello', 'world'],
+    input_modes=['text/plain'],
+    output_modes=['text/plain'],
+    examples=['hello world', 'Hello, World!'],  # moved from AgentCard.examples
+)
+
+agent_card = AgentCard(
+    name='Hello World Agent',
+    description='Returns Hello, World!',
+    supported_interfaces=[
+        # JSON-RPC
+        AgentInterface(
+            protocol_binding='JSONRPC',
+            url='http://localhost:41241/a2a/jsonrpc/',
+        ),
+        # GRPC
+        AgentInterface(
+            protocol_binding='GRPC',
+            url='http://localhost:50051/a2a/grpc/',
+        )
+    ],
+    version='0.0.1',
+    default_input_modes=['text/plain'],
+    default_output_modes=['text/plain'],
+    capabilities=AgentCapabilities(
+        streaming=True,
+        extended_agent_card=True,
+    ),
+    skills=[skill],
+)
+```
+
+> **Example**: [`a2a-mcp-without-framework/server/__main__.py` in PR #509](https://github.com/a2aproject/a2a-samples/pull/509/files#diff-d15d39ae64c3d4e3a36cc6fb442302caf4e32a6dbd858792e7a4bed180a625ac)
+
+---
+
+## 3. Server: DefaultRequestHandler
+
+### Constructor signature: `agent_card` is now required
+
+`DefaultRequestHandler` now requires `agent_card` as a constructor argument (it was previously passed to the application wrapper).
+
+**Before (v0.3):**
+```python
+request_handler = DefaultRequestHandler(
+    agent_executor=MyAgentExecutor(),
+    task_store=InMemoryTaskStore(),
+)
+```
+
+**After (v1.0):**
+```python
+request_handler = DefaultRequestHandler(
+    agent_executor=MyAgentExecutor(),
+    task_store=InMemoryTaskStore(),
+    agent_card=agent_card,
+)
+```
+
+> **Example**: [`a2a-mcp-without-framework/server/__main__.py` in PR #509](https://github.com/a2aproject/a2a-samples/pull/509/files#diff-d15d39ae64c3d4e3a36cc6fb442302caf4e32a6dbd858792e7a4bed180a625ac)
+
+---
+
+## 4. Server: AgentExecutor Streaming Rules
+
+The server now strictly enforces the [A2A spec rules for `SendStreamingMessage`](https://a2a-protocol.org/v1.0.0/specification/#312-send-streaming-message). Existing executors that mix message and task events, or emit task updates before the initial `Task`, will fail at runtime with `InvalidAgentResponseError`. See [PR #979](https://github.com/a2aproject/a2a-python/pull/979).
+
+In v1.0, your `AgentExecutor` MUST follow exactly one of these two streaming patterns:
+
+1. **Message-only stream** — enqueue exactly **one** `Message` and stop.
+2. **Task lifecycle stream** — enqueue a `Task` **first**, then zero or more `TaskStatusUpdateEvent` / `TaskArtifactUpdateEvent` objects until a terminal state is reached.
+
+The following are now hard errors (each raises `InvalidAgentResponseError`):
+
+| Violation | Error message |
+|---|---|
+| Enqueue a `Message` after a `Task` (mixing modes) | *Received Message object in task mode...* |
+| Enqueue more than one `Message` | *Multiple Message objects received.* |
+| Enqueue a `Task`/update event after a `Message` | *Received `<Type>` in message mode...* |
+| Enqueue a `TaskStatusUpdateEvent` before the initial `Task` | *Agent should enqueue Task before `<Type>` event* |
+
+### Migration
+
+**Before (v0.3 — silently tolerated):**
+```python
+from a2a.helpers import new_text_message
+from a2a.server.agent_execution import AgentExecutor
+from a2a.types import TaskStatusUpdateEvent
+
+class MyExecutor(AgentExecutor):
+    async def execute(self, context, event_queue):
+        # Mixing Message and Task events — no longer allowed.
+        await event_queue.enqueue_event(new_text_message('Working on it...'))
+        await event_queue.enqueue_event(
+            TaskStatusUpdateEvent(...)  # ❌ raises InvalidAgentResponseError
+        )
+```
+
+**After (v1.0 — pick one pattern):**
+
+```python
+from a2a.helpers import (
+    new_task_from_user_message,
+    new_text_artifact_update_event,
+    new_text_message,
+    new_text_status_update_event,
+)
+from a2a.server.agent_execution import AgentExecutor
+from a2a.types import Role, TaskState
+
+# Pattern A: Message-only stream — one Message, then done.
+class GreetingExecutor(AgentExecutor):
+    async def execute(self, context, event_queue):
+        await event_queue.enqueue_event(
+            new_text_message('Hello!', role=Role.ROLE_AGENT)
+        )
+
+# Pattern B: Task lifecycle stream — Task first, then updates.
+class WorkflowExecutor(AgentExecutor):
+    def __init__(self, agent):
+        self._agent = agent  # Your underlying agent (LLM, tool, etc.)
+
+    async def execute(self, context, event_queue):
+        task = context.current_task or new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)  # ✅ Task MUST be first
+
+        await event_queue.enqueue_event(
+            new_text_status_update_event(
+                task_id=task.id,
+                context_id=task.context_id,
+                state=TaskState.TASK_STATE_WORKING,
+                text='Processing...',
+            )
+        )
+
+        result = await self._agent.invoke(context.message)
+        await event_queue.enqueue_event(
+            new_text_artifact_update_event(
+                task_id=task.id,
+                context_id=task.context_id,
+                name='result',
+                text=result,
+            )
+        )
+
+        await event_queue.enqueue_event(
+            new_text_status_update_event(
+                task_id=task.id,
+                context_id=task.context_id,
+                state=TaskState.TASK_STATE_COMPLETED,
+                text='Done!',
+            )
+        )
+```
+
+**Quick checklist when migrating an executor:**
+- Decide upfront: is this a one-shot message reply, or a tracked task?
+- If task-based, always enqueue the `Task` object as the very first event.
+- Never mix `Message` events with `TaskStatusUpdateEvent` / `TaskArtifactUpdateEvent` in the same stream.
+- Send only one `Message` per stream when using the message-only pattern.
+
+> **Example**: [`helloworld/agent_executor.py` in PR #474](https://github.com/a2aproject/a2a-samples/pull/474/files#diff-950e8baafcf17d50db5c10b525949407e129995df5295161fbf688e6374ad284)
+
+---
+
+## 5. Server: Application Setup
+
+The application wrapper classes (`A2AStarletteApplication`, `A2AFastApiApplication`, and `A2ARESTFastApiApplication`) have been removed. The server setup now uses Starlette route factory functions directly, giving you better control over routing, middleware, authentication, logging, and other aspects of the server.
+
+**Before (v0.3):**
+```python
+from a2a.server.apps import A2AStarletteApplication
+import uvicorn
+
+# Create application using A2AStarletteApplication wrapper class
+server = A2AStarletteApplication(
+    agent_card=agent_card,
+    http_handler=request_handler,
+)
+
+# Start the server
+uvicorn.run(server.build(), host=host, port=port)
+```
+
+**After (v1.0):**
+
+Define routes for each supported transport as defined in the `AgentCard`.
+
+```python
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+
+# Define routes for transports as defined in the AgentCard
+routes = []
+# A2A Agent Card routes
+routes.extend(create_agent_card_routes(agent_card))
+# JSON-RPC routes
+routes.extend(create_jsonrpc_routes(request_handler, rpc_url='/api/v1/jsonrpc/'))
+
+# Optional: Add routes for REST/HTTP transports
+# routes.extend(create_rest_routes(request_handler, path_prefix='/api/v1/rest/'))
+```
+
+Add the routes to the application:
+
+```python
+from starlette.applications import Starlette
+import uvicorn
+
+# Create application using routes
+app = Starlette(routes=routes)
+
+# Start the server
+uvicorn.run(app, host=host, port=port)
+```
+
+If you prefer FastAPI for your server application:
+
+```python
+from fastapi import FastAPI
+import uvicorn
+
+# Create application using routes
+app = FastAPI(routes=routes)
+
+# Start the server
+uvicorn.run(app, host=host, port=port)
+```
+
+`FastAPI(routes=routes)` mounts the A2A endpoints correctly, but FastAPI's OpenAPI generator only enumerates routes that are `fastapi.routing.APIRoute` instances, so the A2A endpoints will not appear in `/docs` or `/openapi.json`. To make them visible in the auto-generated OpenAPI schema — grouped into Agent Card, JSON-RPC, and REST sections — use the `add_a2a_routes_to_fastapi` helper:
+
+```python
+from fastapi import FastAPI
+import uvicorn
+
+from a2a.server.routes import (
+    add_a2a_routes_to_fastapi,
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+
+app = FastAPI()
+add_a2a_routes_to_fastapi(
+    app,
+    agent_card_routes=create_agent_card_routes(agent_card),
+    jsonrpc_routes=create_jsonrpc_routes(request_handler, rpc_url='/'),
+    rest_routes=create_rest_routes(request_handler),
+)
+
+uvicorn.run(app, host=host, port=port)
+```
+
+> **Example**: [`a2a-mcp-without-framework/server/__main__.py` in PR #509](https://github.com/a2aproject/a2a-samples/pull/509/files#diff-d15d39ae64c3d4e3a36cc6fb442302caf4e32a6dbd858792e7a4bed180a625ac)
+
+---
+
+## 6. Supporting v0.3 Clients
+
+If you cannot update all clients at once, you can run a v1.0 server that also accepts v0.3 connections. Two changes are needed.
+
+**1. Add the v0.3 AgentInterface to `supported_interfaces` in your `AgentCard`**:
+
+```python
+supported_interfaces=[
+    AgentInterface(protocol_binding='JSONRPC', protocol_version='0.3', url='http://localhost:9999/'),
+]
+```
+
+**2. Enable the compat flag** on the relevant route factory:
+
+```python
+create_jsonrpc_routes(request_handler, rpc_url='/', enable_v0_3_compat=True)
+create_rest_routes(request_handler, enable_v0_3_compat=True)
+```
+
+> For a full working example see [`samples/hello_world_agent.py`](../../../samples/hello_world_agent.py). For known limitations see [issue #742](https://github.com/a2aproject/a2a-python/issues/742).
+
+---
+
+## 7. Client: Creating a Client
+
+In `v1.0`, use the `a2a.client.create_client()` helper function to create a `Client` for the agent.
+
+
+**Before (v0.3):**
+```python
+from a2a.client import ClientFactory
+
+# Option 1: Using Agent Server URL
+factory = ClientFactory()
+client = factory.create_client('http://localhost:9999/')
+
+# Option 2: Using AgentCard
+factory = ClientFactory()
+client = factory.create_client(agent_card)
+```
+
+**After (v1.0):**
+```python
+from a2a.client import create_client
+
+# Option 1: Using Agent Server URL
+client = await create_client('http://localhost:9999/')
+
+# Option 2: Using AgentCard
+client = await create_client(agent_card)
+```
+
+
+> **Example**: [`a2a-mcp-without-framework/client/agent.py` in PR #509](https://github.com/a2aproject/a2a-samples/pull/509/files#diff-56cfce97ff9686166e4b14790ffb7ed46f4c14519261ce5c18365a53cf05e9aa) (`create_client()` usage)
+
+---
+
+## 8. Client: Send Message
+
+The `BaseClient.send_message()` return type is standardized from `AsyncIterator[ClientEvent | Message]` to `AsyncIterator[StreamResponse]`.
+
+Each `StreamResponse` contains exactly one of: `task`, `message`, `status_update`, or `artifact_update`. Use `HasField()` to check which field is set.
+
+
+**Before (v0.3):**
+```python
+async for event, message in client.send_message(request):
+    if isinstance(event, Task):
+        ...
+    if isinstance(event, UpdateEvent):
+        ...
+    if message:
+        ...
+```
+
+**After (v1.0):**
+```python
+async for chunk in client.send_message(request):
+    if chunk.HasField('artifact_update'):
+        ...
+    elif chunk.HasField('status_update'):
+        ...
+    elif chunk.HasField('task'):
+        ...
+    elif chunk.HasField('message'):
+        ...
+```
+
+
+---
+
+## 9. Client: Push Notifications Config
+
+`ClientConfig.push_notification_config` is now **singular** (a single `TaskPushNotificationConfig` or `None`), not a list.
+
+
+**Before (v0.3):**
+```python
+config = ClientConfig(
+    push_notification_configs=[my_push_config],
+)
+```
+
+**After (v1.0):**
+```python
+config = ClientConfig(
+    push_notification_config=my_push_config,
+)
+```
+
+---
+
+## 10. Helper Utilities
+
+To improve the developer experience, we have consolidated helper functions into a single import. In v0.3, these helper functions were scattered across different modules. In v1.0, they are all available under `a2a.helpers`.
+
+| Helper Function | Description |
+|---|---|
+| `display_agent_card` | Prints a human-readable summary of an `AgentCard` to stdout. |
+| `get_artifact_text` | Joins all text parts of an `Artifact` into a single string (using `\n` as delimiter). |
+| `get_message_text` | Joins all text parts of a `Message` into a single string (using `\n` as delimiter). |
+| `get_stream_response_text` | Extracts text from a `StreamResponse` protobuf message. |
+| `get_text_parts` | Returns a list of raw text strings from a sequence of `Part` objects, skipping non-text parts. |
+| `new_artifact` | Creates an `Artifact` from a list of `Part` objects, a name, and an optional description and ID. |
+| `new_message` | Creates a `Message` from a list of `Part` objects with a role (defaults to `ROLE_AGENT`), and optional task/context IDs. |
+| `new_task` | Creates a `Task` with an explicit task ID, context ID, and state. |
+| `new_task_from_user_message` | Creates a `TASK_STATE_SUBMITTED` `Task` from a user `Message`. Raises an error if the role is not `ROLE_USER` or if parts are empty. |
+| `new_text_artifact` | Creates an `Artifact` with a single text `Part`, a name, and an optional description and ID. |
+| `new_text_artifact_update_event` | Creates a `TaskArtifactUpdateEvent` with a text artifact. |
+| `new_text_message` | Creates a `Message` with a single text `Part`; role defaults to `ROLE_AGENT`. |
+| `new_text_status_update_event` | Creates a `TaskStatusUpdateEvent` with a text message. |
+
+**Example usage:**
+
+**1. Create a text-based message**
+
+```python
+from a2a.helpers import new_text_message
+from a2a.types import Role
+
+# Create a user message
+user_message = new_text_message("What's the weather?", role=Role.ROLE_USER)
+
+# Create an agent response message
+response_message = new_text_message("It is sunny today!")
+```
+
+**2. Extract text from a message**
+
+```python
+from a2a.helpers import get_message_text
+
+# Get text from a message
+text = get_message_text(response_message)
+print(text)
+```
+
+---
+
+## 11. Summary of Key Changes in v1.0
+
+- **Migration to Protobuf** — Core types have migrated from Pydantic models to Protobuf-based classes. Protobuf objects do not support arbitrary attribute assignment. Use `MessageToDict` from `google.protobuf.json_format` to convert objects to dictionaries, and `HasField('field_name')` to check for optional fields.
+- **Standardization to `SCREAMING_SNAKE_CASE`** — All enum values have been renamed from `snake_case` strings to `SCREAMING_SNAKE_CASE` for compliance with the ProtoJSON specification.
+- **`AgentCard`** — Significantly restructured to support multiple transport interfaces.
+  - **`AgentInterface`** — The top-level `url` field is replaced by `supported_interfaces`, a list of `AgentInterface` objects. Each entry describes a single transport endpoint with fields for `protocol_binding`, `protocol_version`, and `url`.
+  - **Input and output modes** — `AgentCapabilities.input_modes` and `AgentCapabilities.output_modes` are removed and now live directly on `AgentCard` as `default_input_modes` and `default_output_modes`. Individual skills can override these with their own `input_modes` and `output_modes`.
+- **AgentExecutor streaming rules** — The server now strictly enforces the A2A spec: an executor must enqueue either a single `Message` or a `Task` followed by update events (with the `Task` first). Mixing modes, emitting multiple `Message`s, or sending updates before the initial `Task` raises `InvalidAgentResponseError`.
+- **Application setup** — The wrapper classes (`A2AStarletteApplication`, `A2AFastApiApplication`, and `A2ARESTFastApiApplication`) have been removed. Server setup now uses route factory functions — `create_jsonrpc_routes()`, `create_rest_routes()`, and `create_agent_card_routes()` — composed directly into a Starlette or FastAPI app.
+- **Helper utilities** — A new `a2a.helpers` module consolidates all helper functions under a single import, replacing the scattered `a2a.utils.*` modules and adding new helpers for constructing and reading v1.0 proto types.
+
+---
+
+## 12. Get Started
+
+The fastest way to see v1.0 in action is to run the samples:
+
+| File | Role | Description |
+|---|---|---|
+| [`samples/hello_world_agent.py`](../../../samples/hello_world_agent.py) | **Server** | A2A agent exposing JSON-RPC, REST, and gRPC — with v0.3 compat enabled |
+| [`samples/cli.py`](../../../samples/cli.py) | **Client** | Interactive terminal client; supports all three transports |
+
+```bash
+# In one terminal — start the agent:
+uv run python samples/hello_world_agent.py
+
+# In another — connect with the CLI:
+uv run python samples/cli.py
+```
+
+Then type a message like `hello` and press Enter. See [`samples/README.md`](../../../samples/README.md) for full details.
+
+For more examples see the [a2a-samples repository](https://github.com/a2aproject/a2a-samples/tree/main/samples/python).
diff --git a/docs/migrations/v1_0/database/README.md b/docs/migrations/v1_0/database/README.md
new file mode 100644
index 000000000..6cde621d3
--- /dev/null
+++ b/docs/migrations/v1_0/database/README.md
@@ -0,0 +1,22 @@
+# Database Migration Guide: v0.3 to v1.0
+
+The A2A SDK v1.0 introduces significant updates to the database persistence layer, including a new schema for tracking task ownership and protocol versions. This guide provides the necessary steps to migrate your database from v0.3 to the v1.0 persistence model without data loss.
+
+---
+
+## ⚡ Choose Your Migration Strategy
+
+Depending on your application's availability requirements, choose one of the following paths:
+
+| Strategy | Downtime | Complexity | Best For |
+| :--- | :--- | :--- | :--- |
+| **[Simple Migration](simple_migration.md)** | Short (Restart) | Low | Single-instance apps, non-critical services. |
+| **[Zero Downtime Migration](zero_downtime.md)** | None | Medium | Multi-instance, high-availability production environments. |
+
+---
+
+## 🏗️ Technical Overview
+
+The v1.0 database migration involves:
+1.  **Schema Updates**: Adding the `protocol_version`, `owner`, and `last_updated` columns to the `tasks` table, and the `protocol_version` and `owner` columns to the `push_notification_configs` table.
+2.  **Storage Model**: Transitioning from Pydantic-based JSON to Protobuf-based JSON serialization for better interoperability and performance.
diff --git a/docs/migrations/v1_0/database/simple_migration.md b/docs/migrations/v1_0/database/simple_migration.md
new file mode 100644
index 000000000..82561f398
--- /dev/null
+++ b/docs/migrations/v1_0/database/simple_migration.md
@@ -0,0 +1,80 @@
+# Simple Migration: v0.3 to v1.0
+
+This guide is for users who can afford a short period of downtime during the migration from A2A protocol v0.3 to v1.0. This is the recommended path for single-instance applications or non-critical services.
+
+---
+
+> [!WARNING]
+> **Safety First:**
+> Before proceeding, ensure you have a backup of your database.
+
+---
+
+## 🛠 Prerequisites
+
+### Install Migration Tools
+The migration CLI is not included in the base package. Install the `db-cli` extra:
+
+```bash
+uv add "a2a-sdk[db-cli]"
+# OR
+pip install "a2a-sdk[db-cli]"
+```
+
+---
+
+## 🚀 Migration Steps
+
+### Step 1: Apply Schema Updates
+
+Run the `a2a-db` migration tool to update your tables. This adds new columns (`owner`, `protocol_version`, `last_updated`) while leaving existing v0.3 data intact.
+
+```bash
+# Run migration against your target database
+uv run a2a-db --database-url "your-database-url"
+```
+
+> [!NOTE]
+>
+>For more details on the CLI migration tool, including flags, see the [A2A SDK Database Migrations README](../../../../src/a2a/migrations/README.md).
+
+> [!NOTE]
+>
+> The v1.0 database stores are designed to be backward compatible by default. After this step, your new v1.0 code will be able to read existing v0.3 entries from the database using a built-in legacy parser.
+
+### Step 2: Verify the Migration
+
+Confirm the schema is at the correct version:
+
+```bash
+uv run a2a-db current
+```
+The output should show the latest revision ID (e.g., `38ce57e08137`).
+
+### Step 3: Update Your Application Code
+
+Upgrade your application to use the v1.0 SDK.
+
+---
+
+## ↩️ Rollback Strategy
+
+If your application fails to start or encounters errors after the migration:
+
+1.  **Revert Application Code**: Revert your application code to use the v0.3 SDK.
+
+    > [!NOTE]
+    > Older SDKs are compatible with the new schema (as new columns are nullable). If something breaks, rolling back the application code is usually sufficient.
+
+2.  **Revert Schema (Fallback)**: If you encounter database issues, use the `downgrade` command to step back to the v0.3 structure.
+    ```bash
+    uv run a2a-db downgrade -1
+    ```
+3.  **Restart**: Resume operations using the v0.3 SDK.
+
+
+---
+
+## 🧩 Resources
+- **[Zero Downtime Migration](zero_downtime.md)**: If you cannot stop your application.
+- **[a2a-db CLI](../../../../src/a2a/migrations/README.md)**: The primary tool for executing schema migrations.
diff --git a/docs/migrations/v1_0/database/zero_downtime.md b/docs/migrations/v1_0/database/zero_downtime.md
new file mode 100644
index 000000000..026ec88c1
--- /dev/null
+++ b/docs/migrations/v1_0/database/zero_downtime.md
@@ -0,0 +1,132 @@
+# Zero Downtime Migration: v0.3 to v1.0
+
+This guide outlines the strategy for migrating your Agent application from A2A protocol v0.3 to v1.0 without service interruption, even when running multiple distributed instances sharing a single database.
+
+---
+
+> [!WARNING]
+> **Safety First:**
+> Before proceeding, ensure you have a backup of your database.
+
+---
+
+## 🛠 Prerequisites
+
+### Install Migration Tools
+The migration CLI is not included in the base package. Install the `db-cli` extra:
+
+```bash
+uv add "a2a-sdk[db-cli]"
+# OR
+pip install "a2a-sdk[db-cli]"
+```
+
+---
+
+## 🏗️ The 3-Step Strategy
+
+Zero-downtime migration requires an "Expand, Migrate, Contract" pattern. It means we first expand the schema, then migrate the code to coexist with the old format, and finally transition fully to the new v1.0 standards.
+
+### Step 1: Apply Schema Updates
+
+Run the `a2a-db` migration tool to update your tables. This adds new columns (`owner`, `protocol_version`, `last_updated`) while leaving existing v0.3 data intact.
+
+```bash
+# Run migration against your target database
+uv run a2a-db --database-url "your-database-url"
+```
+
+> [!NOTE]
+>
+>For more details on the CLI migration tool, including flags, see the [A2A SDK Database Migrations README](../../../../src/a2a/migrations/README.md).
+
+> [!NOTE]
+> All new columns are nullable. Your existing v0.3 code will continue to work normally after this step is completed.
+>
+> The v1.0 database stores are designed to be backward compatible by default. After this step, your new v1.0 code will be able to read existing v0.3 entries from the database using a built-in legacy parser.
+
+#### ✅ How to Verify
+Confirm the schema is at the correct version:
+
+```bash
+uv run a2a-db current
+```
+The output should show the latest revision ID (e.g., `38ce57e08137`).
+
+### Step 2: Rolling Deployment in Compatibility Mode
+
+In this step, you deploy the v1.0 SDK code but configure it to **write** data in the legacy v0.3 format. This ensures that any v0.3 instances still running in your cluster can read data produced by the new v1.0 instances.
+
+#### Update Initialization Code
+Enable the v0.3 conversion utilities in your application entry point (e.g., `main.py`).
+
+```python
+from a2a.server.tasks import DatabaseTaskStore, DatabasePushNotificationConfigStore
+from a2a.compat.v0_3.model_conversions import (
+    core_to_compat_task_model,
+    core_to_compat_push_notification_config_model,
+)
+
+# Initialize stores with compatibility conversion
+# The '... # other' represents your existing configuration (engine, table_name, etc.)
+task_store = DatabaseTaskStore(
+    ... # other arguments
+    core_to_model_conversion=core_to_compat_task_model
+)
+
+config_store = DatabasePushNotificationConfigStore(
+    ... # other arguments
+    core_to_model_conversion=core_to_compat_push_notification_config_model
+)
+```
+
+#### Perform a Rolling Restart
+Deploy the new code by restarting your instances one by one.
+
+#### ✅ How to Verify
+Verify that v1.0 instances are successfully writing to the database. In the `tasks` and `push_notification_configs` tables, new rows created during this phase should have `protocol_version` set to `0.3`.
+
+### Step 3: Transition to v1.0 Mode
+
+Once **100%** of your application instances are running v1.0 code (with compatibility mode enabled), you can switch to the v1.0 write format.
+
+> [!CAUTION]
+> **CRITICAL PRE-REQUISITE**: Do NOT start Step 3 until you have confirmed that no v0.3 instances remain. Old v0.3 code cannot parse the new v1.0 native database entries.
+
+#### Disable Compatibility Logic
+Remove the `core_to_model_conversion` arguments from your Store constructors.
+
+```python
+# Revert to native v1.0 write behavior
+task_store = DatabaseTaskStore(engine=engine, ...)
+config_store = DatabasePushNotificationConfigStore(engine=engine, ...)
+```
+
+#### Perform a Final Rolling Restart
+
+Restart your instances again.
+
+#### ✅ How to Verify
+Inspect the `tasks` and `push_notification_configs` tables. New entries should now show `protocol_version` as `1.0`.
+
+---
+
+## 🛠️ Why it Works
+
+The A2A `DatabaseStore` classes follow a version-aware read/write pattern:
+
+1.  **Write Logic**: If `core_to_model_conversion` is provided, it is used. Otherwise, it defaults to the v1.0 Protobuf JSON format.
+2.  **Read Logic**: The store automatically inspects the `protocol_version` column for every row. 
+    *   If `NULL` or `0.3`, it uses the internal **v0.3 legacy parser**.
+    *   If `1.0`, it uses the modern **Protobuf parser**.
+
+This allows v1.0 instances to read *all* existing data regardless of when it was written.
+
+---
+
+## 🧩 Resources
+- **[a2a-db CLI](../../../../src/a2a/migrations/README.md)**: The primary tool for executing schema migrations.
+- **[Compatibility Conversions](../../../../src/a2a/compat/v0_3/model_conversions.py)**: Source for model conversion functions `core_to_compat_task_model` and `core_to_compat_push_notification_config_model` used in Step 2.
+- **[Task Store Implementation](../../../../src/a2a/server/tasks/database_task_store.py)**: The `DatabaseTaskStore` which handles the version-aware read/write logic.
+- **[Push Notification Store Implementation](../../../../src/a2a/server/tasks/database_push_notification_config_store.py)**: The `DatabasePushNotificationConfigStore` which handles the version-aware read/write logic.
+
diff --git a/examples/google_adk/birthday_planner/README.md b/examples/google_adk/birthday_planner/README.md
deleted file mode 100644
index 8567f7951..000000000
--- a/examples/google_adk/birthday_planner/README.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# ADK Agent with A2A Client
-
-This example shows how to create an A2A Server that uses an ADK-based Agent that communicates with another agent using A2A.
-
-This agent helps plan birthday parties. It has access to a Calendar Agent that it can delegate calendar-related tasks to. This agent is accessed via A2A.
-
-## Prerequisites
-
-- Python 3.9 or higher
-- [UV](https://docs.astral.sh/uv/)
-- A Gemini API Key
-
-## Running the example
-
-1. Create the .env file with your API Key
-
-```bash
-echo "GOOGLE_API_KEY=your_api_key_here" > .env
-```
-
-2. Run the Calendar Agent. See examples/google_adk/calendar_agent.
-
-3. Run the example
-
-```
-uv run .
-```
\ No newline at end of file
diff --git a/examples/google_adk/birthday_planner/__main__.py b/examples/google_adk/birthday_planner/__main__.py
deleted file mode 100644
index d4a0343dc..000000000
--- a/examples/google_adk/birthday_planner/__main__.py
+++ /dev/null
@@ -1,79 +0,0 @@
-import asyncio
-import functools
-import logging
-import os
-
-import click
-import uvicorn
-from adk_agent_executor import ADKAgentExecutor
-from dotenv import load_dotenv
-
-from a2a.server.apps import A2AStarletteApplication
-from a2a.server.request_handlers import DefaultRequestHandler
-from a2a.server.tasks import InMemoryTaskStore
-from a2a.types import (
-    AgentAuthentication,
-    AgentCapabilities,
-    AgentCard,
-    AgentSkill,
-)
-
-load_dotenv()
-
-logging.basicConfig()
-
-
-def make_sync(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        return asyncio.run(func(*args, **kwargs))
-
-    return wrapper
-
-
-@click.command()
-@click.option('--host', 'host', default='localhost')
-@click.option('--port', 'port', default=10008)
-@click.option(
-    '--calendar-agent', 'calendar_agent', default='http://localhost:10007'
-)
-def main(host: str, port: int, calendar_agent: str):
-    # Verify an API key is set. Not required if using Vertex AI APIs, since those can use gcloud credentials.
-    if not os.getenv('GOOGLE_GENAI_USE_VERTEXAI') == 'TRUE':
-        if not os.getenv('GOOGLE_API_KEY'):
-            raise Exception(
-                'GOOGLE_API_KEY environment variable not set and GOOGLE_GENAI_USE_VERTEXAI is not TRUE.'
-            )
-
-    skill = AgentSkill(
-        id='plan_parties',
-        name='Plan a Birthday Party',
-        description='Plan a birthday party, including times, activities, and themes.',
-        tags=['event-planning'],
-        examples=[
-            'My son is turning 3 on August 2nd! What should I do for his party?',
-            'Can you add the details to my calendar?',
-        ],
-    )
-
-    agent_executor = ADKAgentExecutor(calendar_agent)
-    agent_card = AgentCard(
-        name='Birthday Planner',
-        description='I can help you plan fun birthday parties.',
-        url=f'http://{host}:{port}/',
-        version='1.0.0',
-        defaultInputModes=['text'],
-        defaultOutputModes=['text'],
-        capabilities=AgentCapabilities(streaming=True),
-        skills=[skill],
-        authentication=AgentAuthentication(schemes=['public']),
-    )
-    request_handler = DefaultRequestHandler(
-        agent_executor=agent_executor, task_store=InMemoryTaskStore()
-    )
-    app = A2AStarletteApplication(agent_card, request_handler)
-    uvicorn.run(app.build(), host=host, port=port)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/examples/google_adk/birthday_planner/adk_agent_executor.py b/examples/google_adk/birthday_planner/adk_agent_executor.py
deleted file mode 100644
index 49f13e960..000000000
--- a/examples/google_adk/birthday_planner/adk_agent_executor.py
+++ /dev/null
@@ -1,366 +0,0 @@
-import asyncio
-import logging
-from collections.abc import AsyncGenerator
-from typing import Any, AsyncIterable
-from uuid import uuid4
-
-import httpx
-from google.adk import Runner
-from google.adk.agents import LlmAgent, RunConfig
-from google.adk.artifacts import InMemoryArtifactService
-from google.adk.events import Event
-from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
-from google.adk.sessions import InMemorySessionService
-from google.adk.tools import BaseTool, ToolContext
-from google.genai import types
-from pydantic import ConfigDict
-
-from a2a.client import A2AClient
-from a2a.server.agent_execution import AgentExecutor, RequestContext
-from a2a.server.events.event_queue import EventQueue
-from a2a.server.tasks import TaskUpdater
-from a2a.types import (
-    Artifact,
-    FilePart,
-    FileWithBytes,
-    FileWithUri,
-    GetTaskRequest,
-    GetTaskSuccessResponse,
-    Message,
-    MessageSendParams,
-    Part,
-    Role,
-    SendMessageRequest,
-    SendMessageSuccessResponse,
-    Task,
-    TaskQueryParams,
-    TaskState,
-    TaskStatus,
-    TextPart,
-    UnsupportedOperationError,
-)
-from a2a.utils import get_text_parts
-from a2a.utils.errors import ServerError
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-AUTH_TASK_POLLING_DELAY_SECONDS = 0.2
-
-
-class A2ARunConfig(RunConfig):
-    """Custom override of ADK RunConfig to smuggle extra data through the event loop"""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-    current_task_updater: TaskUpdater
-
-
-class ADKAgentExecutor(AgentExecutor):
-    """An AgentExecutor that runs an ADK-based Agent."""
-
-    def __init__(self, calendar_agent_url):
-        self._agent = LlmAgent(
-            model='gemini-2.0-flash-001',
-            name='birthday_planner_agent',
-            description='An agent that helps manage birthday parties.',
-            after_tool_callback=self._handle_auth_required_task,
-            instruction=f"""
-    You are an agent that helps plan birthday parties.
-
-    Your job as a party planner is to act as a sounding board and idea generator for
-    users who are planning a birthday party.
-
-    You should provide suggestions on, or encourage the user to provide details on:
-    - Venues
-    - Time of day, day of week to hold the party
-    - Age-appropriate activities
-    - Themes for the party
-
-    You can delegate tasks to a separate Calendar Agent that can help manage the user's calendar.
-    """,
-            tools=[self.message_calendar_agent],
-        )
-        self.calendar_agent_endpoint = calendar_agent_url
-        self.runner = Runner(
-            app_name=self._agent.name,
-            agent=self._agent,
-            artifact_service=InMemoryArtifactService(),
-            session_service=InMemorySessionService(),
-            memory_service=InMemoryMemoryService(),
-        )
-
-    def _run_agent(
-        self,
-        session_id,
-        new_message: types.Content,
-        task_updater: TaskUpdater,
-    ) -> AsyncGenerator[Event, None]:
-        return self.runner.run_async(
-            session_id=session_id,
-            user_id='self',
-            new_message=new_message,
-            run_config=A2ARunConfig(current_task_updater=task_updater),
-        )
-
-    async def _handle_auth_required_task(
-        self,
-        tool: BaseTool,
-        args: dict[str, Any],
-        tool_context: ToolContext,
-        tool_response: dict,
-    ) -> dict | None:
-        """Handle requests that return auth-required"""
-        if tool.name != 'message_calendar_agent':
-            return None
-        if not tool_context.state.get('task_suspended'):
-            return None
-        dependent_task = Task.model_validate(
-            tool_context.state['dependent_task']
-        )
-        if dependent_task.status.state != TaskState.auth_required:
-            return None
-        task_updater = self._get_task_updater(tool_context)
-        task_updater.update_status(
-            dependent_task.status.state, message=dependent_task.status.message
-        )
-        # This is not a robust solution. We expect that the calendar agent will only
-        # ever go from auth-required -> completed. A more robust solution would have
-        # more complete state transition handling.
-        task = await self._wait_for_dependent_task(dependent_task)
-        task_updater.update_status(
-            TaskState.working,
-            message=task_updater.new_agent_message(
-                [Part(TextPart(text='Checking calendar agent output'))]
-            ),
-        )
-        tool_context.state['task_suspended'] = False
-        tool_context.state['dependent_task'] = None
-        content = []
-        if task.artifacts:
-            for artifact in task.artifacts:
-                content.extend(get_text_parts(artifact.parts))
-        return {'response': '\n'.join(content)}
-
-    def _get_task_updater(self, tool_context: ToolContext):
-        return tool_context._invocation_context.run_config.current_task_updater
-
-    async def _process_request(
-        self,
-        new_message: types.Content,
-        session_id: str,
-        task_updater: TaskUpdater,
-    ) -> AsyncIterable[TaskStatus | Artifact]:
-        session_id = self._upsert_session(
-            session_id,
-        ).id
-        async for event in self._run_agent(
-            session_id, new_message, task_updater
-        ):
-            logger.debug('Received ADK event: %s', event)
-            if event.is_final_response():
-                response = convert_genai_parts_to_a2a(event.content.parts)
-                logger.debug('Yielding final response: %s', response)
-                task_updater.add_artifact(response)
-                task_updater.complete()
-                break
-            elif calls := event.get_function_calls():
-                for call in calls:
-                    # Provide an update on what we're doing.
-                    if call.name == 'message_calendar_agent':
-                        task_updater.update_status(
-                            TaskState.working,
-                            message=task_updater.new_agent_message(
-                                [
-                                    Part(
-                                        root=TextPart(
-                                            text='Messaging the calendar agent'
-                                        )
-                                    )
-                                ]
-                            ),
-                        )
-            elif not event.get_function_calls():
-                logger.debug('Yielding update response')
-                task_updater.update_status(
-                    TaskState.working,
-                    message=task_updater.new_agent_message(
-                        convert_genai_parts_to_a2a(event.content.parts)
-                    ),
-                )
-            else:
-                logger.debug('Skipping event')
-
-    async def _wait_for_dependent_task(self, dependent_task: Task):
-        async with httpx.AsyncClient() as client:
-            # Subscribe would be good. We'll poll instead.
-            a2a_client = A2AClient(
-                httpx_client=client, url=self.calendar_agent_endpoint
-            )
-            # We want to wait until the task is in a terminal state.
-            while not self._is_task_complete(dependent_task):
-                await asyncio.sleep(AUTH_TASK_POLLING_DELAY_SECONDS)
-                response = await a2a_client.get_task(
-                    GetTaskRequest(params=TaskQueryParams(id=dependent_task.id))
-                )
-                if not isinstance(response.root, GetTaskSuccessResponse):
-                    logger.debug('Getting dependent task failed: %s', response)
-                    # In a real scenario, may want to feed this response back to
-                    # the agent loop to decide what to do. We'll just fail the
-                    # task.
-                    raise Exception('Getting dependent task failed')
-                dependent_task = response.root.result
-            return dependent_task
-
-    def _is_task_complete(self, task: Task) -> bool:
-        return task.status.state == TaskState.completed
-
-    async def execute(
-        self,
-        context: RequestContext,
-        event_queue: EventQueue,
-    ):
-        # Run the agent until either complete or the task is suspended.
-        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
-        # Immediately notify that the task is submitted.
-        if not context.current_task:
-            updater.submit()
-        updater.start_work()
-        await self._process_request(
-            types.UserContent(
-                parts=convert_a2a_parts_to_genai(context.message.parts),
-            ),
-            context.context_id,
-            updater,
-        )
-
-    async def cancel(self, context: RequestContext, event_queue: EventQueue):
-        # Ideally: kill any ongoing tasks.
-        raise ServerError(error=UnsupportedOperationError())
-
-    def _upsert_session(self, session_id: str):
-        return self.runner.session_service.get_session(
-            app_name=self.runner.app_name, user_id='self', session_id=session_id
-        ) or self.runner.session_service.create_session(
-            app_name=self.runner.app_name, user_id='self', session_id=session_id
-        )
-
-    async def message_calendar_agent(
-        self, message: str, tool_context: ToolContext
-    ):
-        """Send a message to the calendar agent."""
-        # We take an overly simplistic approach to the A2A state machine:
-        # - All requests to the calendar agent use the current session ID as the context ID.
-        # - If the last response from the calendar agent (in this session) produced a non-terminal
-        #   task state, the request references that task.
-        request = SendMessageRequest(
-            params=MessageSendParams(
-                message=Message(
-                    contextId=tool_context._invocation_context.session.id,
-                    taskId=tool_context.state.get('task_id'),
-                    messageId=str(uuid4()),
-                    role=Role.user,
-                    parts=[Part(TextPart(text=message))],
-                )
-            )
-        )
-        response = await self._send_agent_message(request)
-        logger.debug('[A2A Client] Received response: %s', response)
-        task_id = None
-        content = []
-        if isinstance(response.root, SendMessageSuccessResponse):
-            if isinstance(response.root.result, Task):
-                task = response.root.result
-                if task.artifacts:
-                    for artifact in task.artifacts:
-                        content.extend(get_text_parts(artifact.parts))
-                if not content:
-                    content.extend(get_text_parts(task.status.message.parts))
-                # Ideally should be "is terminal state"
-                if task.status.state != TaskState.completed:
-                    task_id = task.id
-                if task.status.state == TaskState.auth_required:
-                    tool_context.state['task_suspended'] = True
-                    tool_context.state['dependent_task'] = task.model_dump()
-            else:
-                content.extend(get_text_parts(response.root.result.parts))
-        tool_context.state['task_id'] = task_id
-        # Just turn it all into a string.
-        return {'response': '\n'.join(content)}
-
-    async def _send_agent_message(self, request: SendMessageRequest):
-        async with httpx.AsyncClient() as client:
-            calendar_agent_client = A2AClient(
-                httpx_client=client, url=self.calendar_agent_endpoint
-            )
-            return await calendar_agent_client.send_message(request)
-
-    async def _get_agent_task(self, task_id) -> Task:
-        async with httpx.AsyncClient() as client:
-            a2a_client = A2AClient(
-                httpx_client=client, url=self.calendar_agent_endpoint
-            )
-            await a2a_client.get_task({'id': task_id})
-
-
-def convert_a2a_parts_to_genai(parts: list[Part]) -> list[types.Part]:
-    """Convert a list of A2A Part types into a list of Google GenAI Part types."""
-    return [convert_a2a_part_to_genai(part) for part in parts]
-
-
-def convert_a2a_part_to_genai(part: Part) -> types.Part:
-    """Convert a single A2A Part type into a Google GenAI Part type."""
-    part = part.root
-    if isinstance(part, TextPart):
-        return types.Part(text=part.text)
-    elif isinstance(part, FilePart):
-        if isinstance(part.file, FileWithUri):
-            return types.Part(
-                file_data=types.FileData(
-                    file_uri=part.file.uri, mime_type=part.file.mime_type
-                )
-            )
-        elif isinstance(part.file, FileWithBytes):
-            return types.Part(
-                inline_data=types.Blob(
-                    data=part.file.bytes, mime_type=part.file.mime_type
-                )
-            )
-        else:
-            raise ValueError(f'Unsupported file type: {type(part.file)}')
-    else:
-        raise ValueError(f'Unsupported part type: {type(part)}')
-
-
-def convert_genai_parts_to_a2a(parts: list[types.Part]) -> list[Part]:
-    """Convert a list of Google GenAI Part types into a list of A2A Part types."""
-    return [
-        convert_genai_part_to_a2a(part)
-        for part in parts
-        if (part.text or part.file_data or part.inline_data)
-    ]
-
-
-def convert_genai_part_to_a2a(part: types.Part) -> Part:
-    """Convert a single Google GenAI Part type into an A2A Part type."""
-    if part.text:
-        return TextPart(text=part.text)
-    elif part.file_data:
-        return FilePart(
-            file=FileWithUri(
-                uri=part.file_data.file_uri,
-                mime_type=part.file_data.mime_type,
-            )
-        )
-    elif part.inline_data:
-        return Part(
-            root=FilePart(
-                file=FileWithBytes(
-                    bytes=part.inline_data.data,
-                    mime_type=part.inline_data.mime_type,
-                )
-            )
-        )
-    else:
-        raise ValueError(f'Unsupported part type: {part}')
diff --git a/examples/google_adk/birthday_planner/pyproject.toml b/examples/google_adk/birthday_planner/pyproject.toml
deleted file mode 100644
index 24eaff376..000000000
--- a/examples/google_adk/birthday_planner/pyproject.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[project]
-name = "adk-a2a-client-example"
-version = "0.1.0"
-description = "Birthday planner agent example"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "a2a-sdk",
-    "click>=8.1.8",
-    "dotenv>=0.9.9",
-    "httpx>=0.28.1",
-    "google-genai>=1.9.0",
-    "google-adk>=0.0.3",
-    "pydantic>=2.11.4",
-    "python-dotenv>=1.1.0",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-
-[tool.uv.sources]
-a2a-sdk = { workspace = true }
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
diff --git a/examples/google_adk/calendar_agent/README.md b/examples/google_adk/calendar_agent/README.md
deleted file mode 100644
index 7e2f8e7b2..000000000
--- a/examples/google_adk/calendar_agent/README.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# ADK Agent with Authenticated Tools
-
-This example shows how to create an A2A Server that uses an ADK-based Agent that uses Google-authenticated tools.
-
-## Prerequisites
-
-- Python 3.9 or higher
-- [UV](https://docs.astral.sh/uv/)
-- A Gemini API Key
-- A [Google OAuth Client](https://developers.google.com/identity/openid-connect/openid-connect#getcredentials)
-  - Configure your OAuth client to handle redirect URLs at `localhost:10007/authenticate`
-
-## Running the example
-
-1. Create the .env file with your API Key and OAuth2.0 Client details
-
-```bash
-echo "GOOGLE_API_KEY=your_api_key_here" > .env
-echo "GOOGLE_CLIENT_ID=your_client_id_here" >> .env
-echo "GOOGLE_CLIENT_SECRET=your_client_secret_here" >> .env
-```
-
-2. Run the example
-
-```
-uv run .
-```
diff --git a/examples/google_adk/calendar_agent/__main__.py b/examples/google_adk/calendar_agent/__main__.py
deleted file mode 100644
index 823a14aa2..000000000
--- a/examples/google_adk/calendar_agent/__main__.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import logging
-import os
-
-import click
-import uvicorn
-
-from adk_agent import create_agent
-from adk_agent_executor import ADKAgentExecutor
-from dotenv import load_dotenv
-from google.adk.artifacts import InMemoryArtifactService
-from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from starlette.applications import Starlette
-from starlette.requests import Request
-from starlette.responses import PlainTextResponse
-from starlette.routing import Route
-
-from a2a.server.apps import A2AStarletteApplication
-from a2a.server.request_handlers import DefaultRequestHandler
-from a2a.server.tasks import InMemoryTaskStore
-from a2a.types import (
-    AgentAuthentication,
-    AgentCapabilities,
-    AgentCard,
-    AgentSkill,
-)
-
-
-load_dotenv()
-
-logging.basicConfig()
-
-
-@click.command()
-@click.option('--host', 'host', default='localhost')
-@click.option('--port', 'port', default=10007)
-def main(host: str, port: int):
-    # Verify an API key is set.
-    # Not required if using Vertex AI APIs.
-    if os.getenv('GOOGLE_GENAI_USE_VERTEXAI') != 'TRUE' and not os.getenv(
-        'GOOGLE_API_KEY'
-    ):
-        raise ValueError(
-            'GOOGLE_API_KEY environment variable not set and '
-            'GOOGLE_GENAI_USE_VERTEXAI is not TRUE.'
-        )
-
-    skill = AgentSkill(
-        id='check_availability',
-        name='Check Availability',
-        description="Checks a user's availability for a time using their Google Calendar",
-        tags=['calendar'],
-        examples=['Am I free from 10am to 11am tomorrow?'],
-    )
-
-    agent_card = AgentCard(
-        name='Calendar Agent',
-        description="An agent that can manage a user's calendar",
-        url=f'http://{host}:{port}/',
-        version='1.0.0',
-        defaultInputModes=['text'],
-        defaultOutputModes=['text'],
-        capabilities=AgentCapabilities(streaming=True),
-        skills=[skill],
-        authentication=AgentAuthentication(schemes=['public']),
-    )
-
-    adk_agent = create_agent(
-        client_id=os.getenv('GOOGLE_CLIENT_ID'),
-        client_secret=os.getenv('GOOGLE_CLIENT_SECRET'),
-    )
-    runner = Runner(
-        app_name=agent_card.name,
-        agent=adk_agent,
-        artifact_service=InMemoryArtifactService(),
-        session_service=InMemorySessionService(),
-        memory_service=InMemoryMemoryService(),
-    )
-    agent_executor = ADKAgentExecutor(runner, agent_card)
-
-    async def handle_auth(request: Request) -> PlainTextResponse:
-        await agent_executor.on_auth_callback(
-            request.query_params.get('state'), str(request.url)
-        )
-        return PlainTextResponse('Authentication successful.')
-
-    request_handler = DefaultRequestHandler(
-        agent_executor=agent_executor, task_store=InMemoryTaskStore()
-    )
-
-    a2a_app = A2AStarletteApplication(
-        agent_card=agent_card, http_handler=request_handler
-    )
-    routes = a2a_app.routes()
-    routes.append(
-        Route(
-            path='/authenticate',
-            methods=['GET'],
-            endpoint=handle_auth,
-        )
-    )
-    app = Starlette(routes=routes)
-
-    uvicorn.run(app, host=host, port=port)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/examples/google_adk/calendar_agent/adk_agent.py b/examples/google_adk/calendar_agent/adk_agent.py
deleted file mode 100644
index 4c8cdfe3c..000000000
--- a/examples/google_adk/calendar_agent/adk_agent.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import datetime
-
-from google.adk.agents import LlmAgent
-from google.adk.tools.google_api_tool import calendar_tool_set
-
-
-def create_agent(client_id, client_secret) -> LlmAgent:
-    """Constructs the ADK agent."""
-    calendar_tool_set.configure_auth(client_id, client_secret)
-    return LlmAgent(
-        model='gemini-2.0-flash-001',
-        name='calendar_agent',
-        description="An agent that can help manage a user's calendar",
-        instruction=f"""
-You are an agent that can help manage a user's calendar.
-
-Users will request information about the state of their calendar or to make changes to
-their calendar. Use the provided tools for interacting with the calendar API.
-
-If not specified, assume the calendar the user wants is the 'primary' calendar.
-
-When using the Calendar API tools, use well-formed RFC3339 timestamps.
-
-Today is {datetime.datetime.now()}.
-""",
-        tools=calendar_tool_set.get_tools(),
-    )
diff --git a/examples/google_adk/calendar_agent/adk_agent_executor.py b/examples/google_adk/calendar_agent/adk_agent_executor.py
deleted file mode 100644
index 9182227de..000000000
--- a/examples/google_adk/calendar_agent/adk_agent_executor.py
+++ /dev/null
@@ -1,324 +0,0 @@
-import asyncio
-import logging
-
-from collections import namedtuple
-from collections.abc import AsyncGenerator
-from urllib.parse import parse_qs, urlparse
-
-from google.adk import Runner
-from google.adk.auth import AuthConfig
-from google.adk.events import Event
-from google.genai import types
-
-from a2a.server.agent_execution import AgentExecutor
-from a2a.server.agent_execution.context import RequestContext
-from a2a.server.events.event_queue import EventQueue
-from a2a.server.tasks import TaskUpdater
-from a2a.types import (
-    AgentCard,
-    FilePart,
-    FileWithBytes,
-    FileWithUri,
-    Part,
-    TaskState,
-    TextPart,
-    UnsupportedOperationError,
-)
-from a2a.utils.errors import ServerError
-from a2a.utils.message import new_agent_text_message
-
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-ADKAuthDetails = namedtuple(
-    'ADKAuthDetails',
-    ['state', 'uri', 'future', 'auth_config', 'auth_request_function_call_id'],
-)
-
-# 1 minute timeout to keep the demo moving.
-auth_receive_timeout_seconds = 60
-
-
-class ADKAgentExecutor(AgentExecutor):
-    """An AgentExecutor that runs an ADK-based Agent."""
-
-    _awaiting_auth: dict[str, asyncio.Future]
-
-    def __init__(self, runner: Runner, card: AgentCard):
-        self.runner = runner
-        self._card = card
-        self._awaiting_auth = {}
-        self._running_sessions = {}
-
-    def _run_agent(
-        self, session_id, new_message: types.Content
-    ) -> AsyncGenerator[Event, None]:
-        return self.runner.run_async(
-            session_id=session_id, user_id='self', new_message=new_message
-        )
-
-    async def _process_request(
-        self,
-        new_message: types.Content,
-        session_id: str,
-        task_updater: TaskUpdater,
-    ) -> None:
-        session_id = self._upsert_session(
-            session_id,
-        ).id
-        auth_details = None
-        async for event in self._run_agent(session_id, new_message):
-            # This agent is expected to do one of two things:
-            # 1. Ask follow-up questions.
-            # 2. Call the calendar tool and interpret the results.
-            # So, there are effectively two cases:
-            # 1. The agent was able to run to completion.
-            # 2. The function call required authorization.
-            # Ideally we'd have a way to interpret whether the response is a completion for the
-            # task or requires follow-up, but I'm not going to bother just yet.
-            if auth_request_function_call := get_auth_request_function_call(
-                event
-            ):
-                # Gather details, then suspend.
-                auth_details = self._prepare_auth_request(
-                    auth_request_function_call
-                )
-                logger.debug(
-                    'Yielding auth required response: %s', auth_details.uri
-                )
-                task_updater.update_status(
-                    TaskState.auth_required,
-                    message=new_agent_text_message(
-                        f'Authorization is required to continue. Visit {auth_details.uri}'
-                    ),
-                )
-                # Break out of event handling loop -- no more work will be done until the authorization
-                # is received.
-                break
-            if event.is_final_response():
-                parts = convert_genai_parts_to_a2a(event.content.parts)
-                logger.debug('Yielding final response: %s', parts)
-                task_updater.add_artifact(parts)
-                task_updater.complete()
-                break
-            if not event.get_function_calls():
-                logger.debug('Yielding update response')
-                task_updater.update_status(
-                    TaskState.working,
-                    message=task_updater.new_agent_message(
-                        convert_genai_parts_to_a2a(event.content.parts),
-                    ),
-                )
-            else:
-                logger.debug('Skipping event')
-
-        if auth_details:
-            # After auth is received, we can continue processing this request.
-            await self._complete_auth_processing(
-                session_id, auth_details, task_updater
-            )
-
-    def _prepare_auth_request(
-        self, auth_request_function_call: types.FunctionCall
-    ) -> ADKAuthDetails:
-        # Following ADK's authentication documentation:
-        # https://google.github.io/adk-docs/tools/authentication/#2-handling-the-interactive-oauthoidc-flow-client-side
-        if not (auth_request_function_call_id := auth_request_function_call.id):
-            raise ValueError(
-                f'Cannot get function call id from function call: {auth_request_function_call}'
-            )
-        auth_config = get_auth_config(auth_request_function_call)
-        if not (auth_config and auth_request_function_call_id):
-            raise ValueError(
-                f'Cannot get auth config from function call: {auth_request_function_call}'
-            )
-        oauth2_config = auth_config.exchanged_auth_credential.oauth2
-        base_auth_uri = oauth2_config.auth_uri
-        if not base_auth_uri:
-            raise ValueError(
-                f'Cannot get auth uri from auth config: {auth_config}'
-            )
-        redirect_uri = f'{self._card.url}authenticate'
-        oauth2_config.redirect_uri = redirect_uri
-        parsed_auth_uri = urlparse(base_auth_uri)
-        query_params_dict = parse_qs(parsed_auth_uri.query)
-        state_token = query_params_dict['state'][0]
-        future = asyncio.get_running_loop().create_future()
-        self._awaiting_auth[state_token] = future
-        auth_request_uri = base_auth_uri + f'&redirect_uri={redirect_uri}'
-        return ADKAuthDetails(
-            state=state_token,
-            uri=auth_request_uri,
-            future=future,
-            auth_config=auth_config,
-            auth_request_function_call_id=auth_request_function_call_id,
-        )
-
-    async def _complete_auth_processing(
-        self,
-        session_id: str,
-        auth_details: ADKAuthDetails,
-        task_updater: TaskUpdater,
-    ) -> None:
-        logger.debug('Waiting for auth event')
-        try:
-            auth_uri = await asyncio.wait_for(
-                auth_details.future, timeout=auth_receive_timeout_seconds
-            )
-        except TimeoutError:
-            logger.debug('Timed out waiting for auth, marking task as failed')
-            task_updater.update_status(
-                TaskState.failed,
-                message=new_agent_text_message(
-                    'Timed out waiting for authorization.',
-                    context_id=session_id,
-                ),
-            )
-            return
-        logger.debug('Auth received, continuing')
-        task_updater.update_status(
-            TaskState.working,
-            message=new_agent_text_message(
-                'Auth received, continuing...', context_id=session_id
-            ),
-        )
-        del self._awaiting_auth[auth_details.state]
-        oauth2_config = (
-            auth_details.auth_config.exchanged_auth_credential.oauth2
-        )
-        oauth2_config.auth_response_uri = auth_uri
-        auth_content = types.UserContent(
-            parts=[
-                types.Part(
-                    function_response=types.FunctionResponse(
-                        id=auth_details.auth_request_function_call_id,
-                        name='adk_request_credential',
-                        response=auth_details.auth_config.model_dump(),
-                    ),
-                )
-            ]
-        )
-        await self._process_request(auth_content, session_id, task_updater)
-
-    async def execute(
-        self,
-        context: RequestContext,
-        event_queue: EventQueue,
-    ):
-        # Run the agent until either complete or the task is suspended.
-        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
-        # Immediately notify that the task is submitted.
-        if not context.current_task:
-            updater.submit()
-        updater.start_work()
-        await self._process_request(
-            types.UserContent(
-                parts=convert_a2a_parts_to_genai(context.message.parts),
-            ),
-            context.context_id,
-            updater,
-        )
-        logger.debug('[Calendar] execute exiting')
-
-    async def cancel(self, context: RequestContext, event_queue: EventQueue):
-        # Ideally: kill any ongoing tasks.
-        raise ServerError(error=UnsupportedOperationError())
-
-    async def on_auth_callback(self, state: str, uri: str):
-        self._awaiting_auth[state].set_result(uri)
-
-    def _upsert_session(self, session_id: str):
-        return self.runner.session_service.get_session(
-            app_name=self.runner.app_name, user_id='self', session_id=session_id
-        ) or self.runner.session_service.create_session(
-            app_name=self.runner.app_name, user_id='self', session_id=session_id
-        )
-
-
-def convert_a2a_parts_to_genai(parts: list[Part]) -> list[types.Part]:
-    """Convert a list of A2A Part types into a list of Google Gen AI Part types."""
-    return [convert_a2a_part_to_genai(part) for part in parts]
-
-
-def convert_a2a_part_to_genai(part: Part) -> types.Part:
-    """Convert a single A2A Part type into a Google Gen AI Part type."""
-    part = part.root
-    if isinstance(part, TextPart):
-        return types.Part(text=part.text)
-    if isinstance(part, FilePart):
-        if isinstance(part.file, FileWithUri):
-            return types.Part(
-                file_data=types.FileData(
-                    file_uri=part.file.uri, mime_type=part.file.mime_type
-                )
-            )
-        if isinstance(part.file, FileWithBytes):
-            return types.Part(
-                inline_data=types.Blob(
-                    data=part.file.bytes, mime_type=part.file.mime_type
-                )
-            )
-        raise ValueError(f'Unsupported file type: {type(part.file)}')
-    raise ValueError(f'Unsupported part type: {type(part)}')
-
-
-def convert_genai_parts_to_a2a(parts: list[types.Part]) -> list[Part]:
-    """Convert a list of Google Gen AI Part types into a list of A2A Part types."""
-    return [
-        convert_genai_part_to_a2a(part)
-        for part in parts
-        if (part.text or part.file_data or part.inline_data)
-    ]
-
-
-def convert_genai_part_to_a2a(part: types.Part) -> Part:
-    """Convert a single Google Gen AI Part type into an A2A Part type."""
-    if part.text:
-        return TextPart(text=part.text)
-    if part.file_data:
-        return FilePart(
-            file=FileWithUri(
-                uri=part.file_data.file_uri,
-                mime_type=part.file_data.mime_type,
-            )
-        )
-    if part.inline_data:
-        return Part(
-            root=FilePart(
-                file=FileWithBytes(
-                    bytes=part.inline_data.data,
-                    mime_type=part.inline_data.mime_type,
-                )
-            )
-        )
-    raise ValueError(f'Unsupported part type: {part}')
-
-
-def get_auth_request_function_call(event: Event) -> types.FunctionCall:
-    """Get the special auth request function call from the event."""
-    if not (event.content and event.content.parts):
-        return None
-    for part in event.content.parts:
-        if (
-            part
-            and part.function_call
-            and part.function_call.name == 'adk_request_credential'
-            and event.long_running_tool_ids
-            and part.function_call.id in event.long_running_tool_ids
-        ):
-            return part.function_call
-    return None
-
-
-def get_auth_config(
-    auth_request_function_call: types.FunctionCall,
-) -> AuthConfig:
-    """Extracts the AuthConfig object from the arguments of the auth request function call."""
-    if not auth_request_function_call.args or not (
-        auth_config := auth_request_function_call.args.get('auth_config')
-    ):
-        raise ValueError(
-            f'Cannot get auth config from function call: {auth_request_function_call}'
-        )
-    return AuthConfig.model_validate(auth_config)
diff --git a/examples/google_adk/calendar_agent/pyproject.toml b/examples/google_adk/calendar_agent/pyproject.toml
deleted file mode 100644
index c2e53ee0a..000000000
--- a/examples/google_adk/calendar_agent/pyproject.toml
+++ /dev/null
@@ -1,27 +0,0 @@
-[project]
-name = "adk-auth-example"
-version = "0.1.0"
-description = "Calendar agent example"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "a2a-sdk",
-    "click>=8.1.8",
-    "dotenv>=0.9.9",
-    "httpx>=0.28.1",
-    "google-genai>=1.9.0",
-    "google-adk>=0.0.3",
-    "pydantic>=2.11.4",
-    "python-dotenv>=1.1.0",
-    "uvicorn>=0.34.2",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-
-[tool.uv.sources]
-a2a-sdk = { workspace = true }
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
diff --git a/examples/helloworld/README.md b/examples/helloworld/README.md
deleted file mode 100644
index 1e82c148b..000000000
--- a/examples/helloworld/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Hello World Example
-
-Hello World example agent that only returns Message events
-
-## Getting started
-
-1. Start the server
-
-   ```bash
-   uv run .
-   ```
-
-2. Run the test client
-
-   ```bash
-   uv run test_client.py
-   ```
diff --git a/examples/helloworld/__main__.py b/examples/helloworld/__main__.py
deleted file mode 100644
index ba06207b1..000000000
--- a/examples/helloworld/__main__.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from agent_executor import HelloWorldAgentExecutor
-
-from a2a.server.apps import A2AStarletteApplication
-from a2a.server.request_handlers import DefaultRequestHandler
-from a2a.server.tasks import InMemoryTaskStore
-from a2a.types import (
-    AgentAuthentication,
-    AgentCapabilities,
-    AgentCard,
-    AgentSkill,
-)
-
-
-if __name__ == '__main__':
-    skill = AgentSkill(
-        id='hello_world',
-        name='Returns hello world',
-        description='just returns hello world',
-        tags=['hello world'],
-        examples=['hi', 'hello world'],
-    )
-
-    agent_card = AgentCard(
-        name='Hello World Agent',
-        description='Just a hello world agent',
-        url='http://localhost:9999/',
-        version='1.0.0',
-        defaultInputModes=['text'],
-        defaultOutputModes=['text'],
-        capabilities=AgentCapabilities(streaming=True),
-        skills=[skill],
-        authentication=AgentAuthentication(schemes=['public']),
-    )
-
-    request_handler = DefaultRequestHandler(
-        agent_executor=HelloWorldAgentExecutor(),
-        task_store=InMemoryTaskStore(),
-    )
-
-    server = A2AStarletteApplication(
-        agent_card=agent_card, http_handler=request_handler
-    )
-    import uvicorn
-
-    uvicorn.run(server.build(), host='0.0.0.0', port=9999)
diff --git a/examples/helloworld/agent_executor.py b/examples/helloworld/agent_executor.py
deleted file mode 100644
index ed13dbc76..000000000
--- a/examples/helloworld/agent_executor.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from typing_extensions import override
-
-from a2a.server.agent_execution import AgentExecutor, RequestContext
-from a2a.server.events import EventQueue
-from a2a.utils import new_agent_text_message
-
-
-class HelloWorldAgent:
-    """Hello World Agent."""
-
-    async def invoke(self) -> str:
-        return 'Hello World'
-
-
-class HelloWorldAgentExecutor(AgentExecutor):
-    """Test AgentProxy Implementation."""
-
-    def __init__(self):
-        self.agent = HelloWorldAgent()
-
-    @override
-    async def execute(
-        self,
-        context: RequestContext,
-        event_queue: EventQueue,
-    ) -> None:
-        result = await self.agent.invoke()
-        event_queue.enqueue_event(new_agent_text_message(result))
-
-    @override
-    async def cancel(
-        self, context: RequestContext, event_queue: EventQueue
-    ) -> None:
-        raise Exception('cancel not supported')
diff --git a/examples/helloworld/pyproject.toml b/examples/helloworld/pyproject.toml
deleted file mode 100644
index 1966d2f97..000000000
--- a/examples/helloworld/pyproject.toml
+++ /dev/null
@@ -1,27 +0,0 @@
-[project]
-name = "helloworld"
-version = "0.1.0"
-description = "HelloWorld agent example that only returns Messages"
-readme = "README.md"
-requires-python = ">=3.13"
-dependencies = [
-    "a2a-sdk",
-    "click>=8.1.8",
-    "dotenv>=0.9.9",
-    "httpx>=0.28.1",
-    "langchain-google-genai>=2.1.4",
-    "langgraph>=0.4.1",
-    "pydantic>=2.11.4",
-    "python-dotenv>=1.1.0",
-    "uvicorn>=0.34.2",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-
-[tool.uv.sources]
-a2a-sdk = { workspace = true }
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
diff --git a/examples/helloworld/test_client.py b/examples/helloworld/test_client.py
deleted file mode 100644
index 0ade8d2a8..000000000
--- a/examples/helloworld/test_client.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from a2a.client import A2AClient
-from typing import Any
-import httpx
-from uuid import uuid4
-from a2a.types import (
-    SendMessageRequest,
-    MessageSendParams,
-    SendStreamingMessageRequest,
-)
-
-
-async def main() -> None:
-    async with httpx.AsyncClient() as httpx_client:
-        client = await A2AClient.get_client_from_agent_card_url(
-            httpx_client, 'http://localhost:9999'
-        )
-        send_message_payload: dict[str, Any] = {
-            'message': {
-                'role': 'user',
-                'parts': [
-                    {'type': 'text', 'text': 'how much is 10 USD in INR?'}
-                ],
-                'messageId': uuid4().hex,
-            },
-        }
-        request = SendMessageRequest(
-            params=MessageSendParams(**send_message_payload)
-        )
-
-        response = await client.send_message(request)
-        print(response.model_dump(mode='json', exclude_none=True))
-
-        streaming_request = SendStreamingMessageRequest(
-            params=MessageSendParams(**send_message_payload)
-        )
-
-        stream_response = client.send_message_streaming(streaming_request)
-        async for chunk in stream_response:
-            print(chunk.model_dump(mode='json', exclude_none=True))
-
-
-if __name__ == '__main__':
-    import asyncio
-
-    asyncio.run(main())
diff --git a/examples/langgraph/README.md b/examples/langgraph/README.md
deleted file mode 100644
index f66e98082..000000000
--- a/examples/langgraph/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# LangGraph example
-
-An example LangGraph agent that helps with currency conversion.
-
-## Getting started
-
-1. Extract the zip file and cd to examples folder
-
-2. Create an environment file with your API key:
-
-   ```bash
-   echo "GOOGLE_API_KEY=your_api_key_here" > .env
-   ```
-
-3. Start the server
-
-   ```bash
-   uv run main.py
-   ```
-
-4. Run the test client
-
-   ```bash
-   uv run test_client.py
-   ```
diff --git a/examples/langgraph/__main__.py b/examples/langgraph/__main__.py
deleted file mode 100644
index af06aeaee..000000000
--- a/examples/langgraph/__main__.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import os
-import sys
-
-import click
-
-from agent import CurrencyAgent
-from agent_executor import CurrencyAgentExecutor
-from dotenv import load_dotenv
-
-from a2a.server.apps import A2AStarletteApplication
-from a2a.server.request_handlers import DefaultRequestHandler
-from a2a.server.tasks import InMemoryTaskStore
-from a2a.types import (
-    AgentAuthentication,
-    AgentCapabilities,
-    AgentCard,
-    AgentSkill,
-)
-
-
-load_dotenv()
-
-
-@click.command()
-@click.option('--host', 'host', default='localhost')
-@click.option('--port', 'port', default=10000)
-def main(host: str, port: int):
-    if not os.getenv('GOOGLE_API_KEY'):
-        print('GOOGLE_API_KEY environment variable not set.')
-        sys.exit(1)
-
-    request_handler = DefaultRequestHandler(
-        agent_executor=CurrencyAgentExecutor(),
-        task_store=InMemoryTaskStore(),
-    )
-
-    server = A2AStarletteApplication(
-        agent_card=get_agent_card(host, port), http_handler=request_handler
-    )
-    import uvicorn
-
-    uvicorn.run(server.build(), host=host, port=port)
-
-
-def get_agent_card(host: str, port: int):
-    """Returns the Agent Card for the Currency Agent."""
-    capabilities = AgentCapabilities(streaming=True, pushNotifications=True)
-    skill = AgentSkill(
-        id='convert_currency',
-        name='Currency Exchange Rates Tool',
-        description='Helps with exchange values between various currencies',
-        tags=['currency conversion', 'currency exchange'],
-        examples=['What is exchange rate between USD and GBP?'],
-    )
-    return AgentCard(
-        name='Currency Agent',
-        description='Helps with exchange rates for currencies',
-        url=f'http://{host}:{port}/',
-        version='1.0.0',
-        defaultInputModes=CurrencyAgent.SUPPORTED_CONTENT_TYPES,
-        defaultOutputModes=CurrencyAgent.SUPPORTED_CONTENT_TYPES,
-        capabilities=capabilities,
-        skills=[skill],
-        authentication=AgentAuthentication(schemes=['public']),
-    )
-
-
-if __name__ == '__main__':
-    main()
diff --git a/examples/langgraph/agent.py b/examples/langgraph/agent.py
deleted file mode 100644
index 409995cc7..000000000
--- a/examples/langgraph/agent.py
+++ /dev/null
@@ -1,150 +0,0 @@
-import logging
-
-from collections.abc import AsyncIterable
-from typing import Any, Literal
-
-import httpx
-
-from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.runnables.config import (
-    RunnableConfig,
-)
-from langchain_core.tools import tool  # type: ignore
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.prebuilt import create_react_agent  # type: ignore
-from pydantic import BaseModel
-
-
-logger = logging.getLogger(__name__)
-
-memory = MemorySaver()
-
-
-@tool
-def get_exchange_rate(
-    currency_from: str = 'USD',
-    currency_to: str = 'EUR',
-    currency_date: str = 'latest',
-):
-    """Use this to get current exchange rate.
-
-    Args:
-        currency_from: The currency to convert from (e.g., "USD").
-        currency_to: The currency to convert to (e.g., "EUR").
-        currency_date: The date for the exchange rate or "latest". Defaults to "latest".
-
-    Returns:
-        A dictionary containing the exchange rate data, or an error message if the request fails.
-    """
-    try:
-        response = httpx.get(
-            f'https://api.frankfurter.app/{currency_date}',
-            params={'from': currency_from, 'to': currency_to},
-        )
-        response.raise_for_status()
-
-        data = response.json()
-        if 'rates' not in data:
-            logger.error(f'rates not found in response: {data}')
-            return {'error': 'Invalid API response format.'}
-        logger.info(f'API response: {data}')
-        return data
-    except httpx.HTTPError as e:
-        logger.error(f'API request failed: {e}')
-        return {'error': f'API request failed: {e}'}
-    except ValueError:
-        logger.error('Invalid JSON response from API')
-        return {'error': 'Invalid JSON response from API.'}
-
-
-class ResponseFormat(BaseModel):
-    """Respond to the user in this format."""
-
-    status: Literal['input_required', 'completed', 'error'] = 'input_required'
-    message: str
-
-
-class CurrencyAgent:
-    """Currency Conversion Agent Example."""
-
-    SYSTEM_INSTRUCTION = (
-        'You are a specialized assistant for currency conversions. '
-        "Your sole purpose is to use the 'get_exchange_rate' tool to answer questions about currency exchange rates. "
-        'If the user asks about anything other than currency conversion or exchange rates, '
-        'politely state that you cannot help with that topic and can only assist with currency-related queries. '
-        'Do not attempt to answer unrelated questions or use tools for other purposes.'
-    )
-
-    RESPONSE_FORMAT_INSTRUCTION: str = (
-        'Select status as completed if the request is complete'
-        'Select status as input_required if the input is a question to the user'
-        'Set response status to error if the input indicates an error'
-    )
-
-    def __init__(self):
-        self.model = ChatGoogleGenerativeAI(model='gemini-2.0-flash')
-        self.tools = [get_exchange_rate]
-
-        self.graph = create_react_agent(
-            self.model,
-            tools=self.tools,
-            checkpointer=memory,
-            prompt=self.SYSTEM_INSTRUCTION,
-            response_format=(self.RESPONSE_FORMAT_INSTRUCTION, ResponseFormat),
-        )
-
-    async def stream(
-        self, query: str, sessionId: str
-    ) -> AsyncIterable[dict[str, Any]]:
-        inputs: dict[str, Any] = {'messages': [('user', query)]}
-        config: RunnableConfig = {'configurable': {'thread_id': sessionId}}
-
-        for item in self.graph.stream(inputs, config, stream_mode='values'):
-            message = item['messages'][-1]
-            if (
-                isinstance(message, AIMessage)
-                and message.tool_calls
-                and len(message.tool_calls) > 0
-            ):
-                yield {
-                    'is_task_complete': False,
-                    'require_user_input': False,
-                    'content': 'Looking up the exchange rates...',
-                }
-            elif isinstance(message, ToolMessage):
-                yield {
-                    'is_task_complete': False,
-                    'require_user_input': False,
-                    'content': 'Processing the exchange rates..',
-                }
-
-        yield self.get_agent_response(config)
-
-    def get_agent_response(self, config: RunnableConfig) -> dict[str, Any]:
-        current_state = self.graph.get_state(config)
-
-        structured_response = current_state.values.get('structured_response')
-        if structured_response and isinstance(
-            structured_response, ResponseFormat
-        ):
-            if structured_response.status in {'input_required', 'error'}:
-                return {
-                    'is_task_complete': False,
-                    'require_user_input': True,
-                    'content': structured_response.message,
-                }
-            if structured_response.status == 'completed':
-                return {
-                    'is_task_complete': True,
-                    'require_user_input': False,
-                    'content': structured_response.message,
-                }
-
-        return {
-            'is_task_complete': False,
-            'require_user_input': True,
-            'content': 'We are unable to process your request at the moment. Please try again.',
-        }
-
-    SUPPORTED_CONTENT_TYPES = ['text', 'text/plain']
diff --git a/examples/langgraph/agent_executor.py b/examples/langgraph/agent_executor.py
deleted file mode 100644
index 5e2ed77aa..000000000
--- a/examples/langgraph/agent_executor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from agent import CurrencyAgent
-from typing_extensions import override
-
-from a2a.server.agent_execution import AgentExecutor, RequestContext
-from a2a.server.events.event_queue import EventQueue
-from a2a.types import (
-    TaskArtifactUpdateEvent,
-    TaskState,
-    TaskStatus,
-    TaskStatusUpdateEvent,
-)
-from a2a.utils import new_agent_text_message, new_task, new_text_artifact
-
-
-class CurrencyAgentExecutor(AgentExecutor):
-    """Currency AgentExecutor Example."""
-
-    def __init__(self):
-        self.agent = CurrencyAgent()
-
-    @override
-    async def execute(
-        self,
-        context: RequestContext,
-        event_queue: EventQueue,
-    ) -> None:
-        query = context.get_user_input()
-        task = context.current_task
-
-        if not context.message:
-            raise Exception('No message provided')
-
-        if not task:
-            task = new_task(context.message)
-            event_queue.enqueue_event(task)
-        # invoke the underlying agent, using streaming results
-        async for event in self.agent.stream(query, task.contextId):
-            if event['is_task_complete']:
-                event_queue.enqueue_event(
-                    TaskArtifactUpdateEvent(
-                        append=False,
-                        contextId=task.contextId,
-                        taskId=task.id,
-                        lastChunk=True,
-                        artifact=new_text_artifact(
-                            name='current_result',
-                            description='Result of request to agent.',
-                            text=event['content'],
-                        ),
-                    )
-                )
-                event_queue.enqueue_event(
-                    TaskStatusUpdateEvent(
-                        status=TaskStatus(state=TaskState.completed),
-                        final=True,
-                        contextId=task.contextId,
-                        taskId=task.id,
-                    )
-                )
-            elif event['require_user_input']:
-                event_queue.enqueue_event(
-                    TaskStatusUpdateEvent(
-                        status=TaskStatus(
-                            state=TaskState.input_required,
-                            message=new_agent_text_message(
-                                event['content'],
-                                task.contextId,
-                                task.id,
-                            ),
-                        ),
-                        final=True,
-                        contextId=task.contextId,
-                        taskId=task.id,
-                    )
-                )
-            else:
-                event_queue.enqueue_event(
-                    TaskStatusUpdateEvent(
-                        status=TaskStatus(
-                            state=TaskState.working,
-                            message=new_agent_text_message(
-                                event['content'],
-                                task.contextId,
-                                task.id,
-                            ),
-                        ),
-                        final=False,
-                        contextId=task.contextId,
-                        taskId=task.id,
-                    )
-                )
-
-    @override
-    async def cancel(
-        self, context: RequestContext, event_queue: EventQueue
-    ) -> None:
-        raise Exception('cancel not supported')
diff --git a/examples/langgraph/helpers.py b/examples/langgraph/helpers.py
deleted file mode 100644
index 66a4d5a95..000000000
--- a/examples/langgraph/helpers.py
+++ /dev/null
@@ -1,95 +0,0 @@
-from datetime import datetime
-from typing import Any
-from uuid import uuid4
-
-from a2a.types import (
-    Artifact,
-    Message,
-    Part,
-    Role,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskState,
-    TaskStatus,
-    TaskStatusUpdateEvent,
-    TextPart,
-)
-
-
-def update_task_with_agent_response(
-    task: Task, agent_response: dict[str, Any]
-) -> None:
-    """Updates the provided task with the agent response."""
-    task.status.timestamp = datetime.now().isoformat()
-    parts: list[Part] = [Part(root=TextPart(text=agent_response['content']))]
-    if agent_response['require_user_input']:
-        task.status.state = TaskState.input_required
-        message = Message(
-            messageId=str(uuid4()),
-            role=Role.agent,
-            parts=parts,
-        )
-        task.status.message = message
-        if not task.history:
-            task.history = []
-
-        task.history.append(message)
-    else:
-        task.status.state = TaskState.completed
-        task.status.message = None
-        if not task.artifacts:
-            task.artifacts = []
-
-        artifact: Artifact = Artifact(parts=parts, artifactId=str(uuid4()))
-        task.artifacts.append(artifact)
-
-
-def process_streaming_agent_response(
-    task: Task,
-    agent_response: dict[str, Any],
-) -> tuple[TaskArtifactUpdateEvent | None, TaskStatusUpdateEvent]:
-    """Processes the streaming agent responses and returns TaskArtifactUpdateEvent and TaskStatusUpdateEvent."""
-    is_task_complete = agent_response['is_task_complete']
-    require_user_input = agent_response['require_user_input']
-    parts: list[Part] = [Part(root=TextPart(text=agent_response['content']))]
-
-    end_stream = False
-    artifact = None
-    message = None
-
-    # responses from this agent can be working/completed/input-required
-    if not is_task_complete and not require_user_input:
-        task_state = TaskState.working
-        message = Message(role=Role.agent, parts=parts, messageId=str(uuid4()))
-    elif require_user_input:
-        task_state = TaskState.input_required
-        message = Message(role=Role.agent, parts=parts, messageId=str(uuid4()))
-        end_stream = True
-    else:
-        task_state = TaskState.completed
-        artifact = Artifact(parts=parts, artifactId=str(uuid4()))
-        end_stream = True
-
-    task_artifact_update_event = None
-
-    if artifact:
-        task_artifact_update_event = TaskArtifactUpdateEvent(
-            taskId=task.id,
-            contextId=task.contextId,
-            artifact=artifact,
-            append=False,
-            lastChunk=True,
-        )
-
-    task_status_event = TaskStatusUpdateEvent(
-        taskId=task.id,
-        contextId=task.contextId,
-        status=TaskStatus(
-            state=task_state,
-            message=message,
-            timestamp=datetime.now().isoformat(),
-        ),
-        final=end_stream,
-    )
-
-    return task_artifact_update_event, task_status_event
diff --git a/examples/langgraph/pyproject.toml b/examples/langgraph/pyproject.toml
deleted file mode 100644
index 1921bf55c..000000000
--- a/examples/langgraph/pyproject.toml
+++ /dev/null
@@ -1,27 +0,0 @@
-[project]
-name = "langgraph-example"
-version = "0.1.0"
-description = "Currency conversion agent example"
-readme = "README.md"
-requires-python = ">=3.13"
-dependencies = [
-    "a2a-sdk",
-    "click>=8.1.8",
-    "dotenv>=0.9.9",
-    "httpx>=0.28.1",
-    "langchain-google-genai>=2.1.4",
-    "langgraph>=0.4.1",
-    "pydantic>=2.11.4",
-    "python-dotenv>=1.1.0",
-    "uvicorn>=0.34.2",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-
-[tool.uv.sources]
-a2a-sdk = { workspace = true }
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
diff --git a/examples/langgraph/test_client.py b/examples/langgraph/test_client.py
deleted file mode 100644
index 01d925aee..000000000
--- a/examples/langgraph/test_client.py
+++ /dev/null
@@ -1,164 +0,0 @@
-from a2a.client import A2AClient
-from typing import Any
-from uuid import uuid4
-from a2a.types import (
-    SendMessageResponse,
-    GetTaskResponse,
-    SendMessageSuccessResponse,
-    Task,
-    TaskState,
-    SendMessageRequest,
-    MessageSendParams,
-    GetTaskRequest,
-    TaskQueryParams,
-    SendStreamingMessageRequest,
-)
-import httpx
-import traceback
-
-AGENT_URL = 'http://localhost:10000'
-
-
-def create_send_message_payload(
-    text: str, task_id: str | None = None, context_id: str | None = None
-) -> dict[str, Any]:
-    """Helper function to create the payload for sending a task."""
-    payload: dict[str, Any] = {
-        'message': {
-            'role': 'user',
-            'parts': [{'type': 'text', 'text': text}],
-            'messageId': uuid4().hex,
-        },
-    }
-
-    if task_id:
-        payload['message']['taskId'] = task_id
-
-    if context_id:
-        payload['message']['contextId'] = context_id
-    return payload
-
-
-def print_json_response(response: Any, description: str) -> None:
-    """Helper function to print the JSON representation of a response."""
-    print(f'--- {description} ---')
-    if hasattr(response, 'root'):
-        print(f'{response.root.model_dump_json(exclude_none=True)}\n')
-    else:
-        print(f'{response.model_dump(mode="json", exclude_none=True)}\n')
-
-
-async def run_single_turn_test(client: A2AClient) -> None:
-    """Runs a single-turn non-streaming test."""
-
-    send_payload = create_send_message_payload(
-        text='how much is 100 USD in CAD?'
-    )
-    request = SendMessageRequest(params=MessageSendParams(**send_payload))
-
-    print('--- Single Turn Request ---')
-    # Send Message
-    send_response: SendMessageResponse = await client.send_message(request)
-    print_json_response(send_response, 'Single Turn Request Response')
-    if not isinstance(send_response.root, SendMessageSuccessResponse):
-        print('received non-success response. Aborting get task ')
-        return
-
-    if not isinstance(send_response.root.result, Task):
-        print('received non-task response. Aborting get task ')
-        return
-
-    task_id: str = send_response.root.result.id
-    print('---Query Task---')
-    # query the task
-    task_id_payload = {'id': task_id}
-    get_request = GetTaskRequest(params=TaskQueryParams(**task_id_payload))
-    get_response: GetTaskResponse = await client.get_task(get_request)
-    print_json_response(get_response, 'Query Task Response')
-
-
-async def run_streaming_test(client: A2AClient) -> None:
-    """Runs a single-turn streaming test."""
-
-    send_payload = create_send_message_payload(
-        text='how much is 50 EUR in JPY?'
-    )
-
-    request = SendStreamingMessageRequest(
-        params=MessageSendParams(**send_payload)
-    )
-
-    print('--- Single Turn Streaming Request ---')
-    stream_response = client.send_message_streaming(request)
-    async for chunk in stream_response:
-        print_json_response(chunk, 'Streaming Chunk')
-
-
-async def run_multi_turn_test(client: A2AClient) -> None:
-    """Runs a multi-turn non-streaming test."""
-    print('--- Multi-Turn Request ---')
-    # --- First Turn ---
-
-    first_turn_payload = create_send_message_payload(
-        text='how much is 100 USD?'
-    )
-    request1 = SendMessageRequest(
-        params=MessageSendParams(**first_turn_payload)
-    )
-    first_turn_response: SendMessageResponse = await client.send_message(
-        request1
-    )
-    print_json_response(first_turn_response, 'Multi-Turn: First Turn Response')
-
-    context_id: str | None = None
-    if isinstance(
-        first_turn_response.root, SendMessageSuccessResponse
-    ) and isinstance(first_turn_response.root.result, Task):
-        task: Task = first_turn_response.root.result
-        context_id = task.contextId  # Capture context ID
-
-        # --- Second Turn (if input required) ---
-        if task.status.state == TaskState.input_required and context_id:
-            print('--- Multi-Turn: Second Turn (Input Required) ---')
-            second_turn_payload = create_send_message_payload(
-                'in GBP', task.id, context_id
-            )
-            request2 = SendMessageRequest(
-                params=MessageSendParams(**second_turn_payload)
-            )
-            second_turn_response = await client.send_message(request2)
-            print_json_response(
-                second_turn_response, 'Multi-Turn: Second Turn Response'
-            )
-        elif not context_id:
-            print('Warning: Could not get context ID from first turn response.')
-        else:
-            print(
-                'First turn completed, no further input required for this test case.'
-            )
-
-
-async def main() -> None:
-    """Main function to run the tests."""
-    print(f'Connecting to agent at {AGENT_URL}...')
-    try:
-        async with httpx.AsyncClient() as httpx_client:
-            client = await A2AClient.get_client_from_agent_card_url(
-                httpx_client, AGENT_URL
-            )
-            print('Connection successful.')
-
-            await run_single_turn_test(client)
-            await run_streaming_test(client)
-            await run_multi_turn_test(client)
-
-    except Exception as e:
-        traceback.print_exc()
-        print(f'An error occurred: {e}')
-        print('Ensure the agent server is running.')
-
-
-if __name__ == '__main__':
-    import asyncio
-
-    asyncio.run(main())
diff --git a/itk/README.md b/itk/README.md
new file mode 100644
index 000000000..08faed520
--- /dev/null
+++ b/itk/README.md
@@ -0,0 +1,74 @@
+# Running ITK Tests Locally
+
+This directory contains scripts to run Integration Test Kit (ITK) tests locally using Podman.
+
+## Prerequisites
+
+### 1. Install Podman
+
+Run the following commands to install Podman and its components:
+
+```bash
+sudo apt update && sudo apt install -y podman podman-docker podman-compose
+```
+
+### 2. Configure SubUIDs/SubGIDs
+
+For rootless Podman to function correctly, you need to ensure subuids and subgids are configured for your user.
+
+If they are not already configured, you can add them using (replace `$USER` with your username if needed):
+
+```bash
+sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER
+```
+
+After adding subuids or if you encounter permission issues, run:
+
+```bash
+podman system migrate
+```
+
+## Running Tests
+
+### 1. Set Environment Variable
+
+You must set the `A2A_ITK_REVISION` environment variable to specify which revision of the `a2a-itk` repository to use for testing. This can be a branch name, tag, or commit hash.
+
+Example:
+```
+export A2A_ITK_REVISION=main
+```
+
+### 2. Execute Tests
+
+Run the test script from this directory:
+
+```bash
+./run_itk.sh
+```
+
+The script will:
+- Clone `a2a-itk` (if not already present).
+- Checkout the specified revision.
+- Build the ITK service Docker image.
+- Run the tests and output results.
+
+## Debugging
+
+To enable debug logging and persist logs for inspection:
+
+1.  Set the `ITK_LOG_LEVEL` environment variable to `DEBUG`:
+
+    ```bash
+    export ITK_LOG_LEVEL=DEBUG
+    ```
+2.  Run the test script:
+    ```bash
+    ./run_itk.sh
+    ```
+
+When run in `DEBUG` mode:
+- The `logs/` directory will be created in this directory (if it doesn't exist).
+- The `logs/` directory will be mounted to the container.
+- The test execution will produce detailed logs in `logs/` (e.g., `agent_current.log`).
+- The `logs/` directory will **not** be removed during cleanup.
diff --git a/examples/helloworld/__init__.py b/itk/__init__.py
similarity index 100%
rename from examples/helloworld/__init__.py
rename to itk/__init__.py
diff --git a/itk/acts_behaviors.py b/itk/acts_behaviors.py
new file mode 100644
index 000000000..eead94c2b
--- /dev/null
+++ b/itk/acts_behaviors.py
@@ -0,0 +1,367 @@
+"""The ACTS SUT behaviour contract (ACTS spec §11) for the ITK agent.
+
+ACTS tests are declarative — they say what to send and what to expect — so the
+agent under test has to produce a *deterministic* reply for each case. §11
+does that with a message-prefix convention rather than a side-channel API: the
+text of the first user message part names the behaviour, and the agent obeys.
+
+This module owns that mapping. `itk/main.py` routes to it when the first user
+message starts with ``tck-``, and otherwise falls through to the existing ITK
+instruction path, so one agent binary serves both suites.
+
+**The behaviour is a property of the task, not of the message.** A multi-turn
+test opens with ``tck-multi-turn start`` and then sends plain ``here is more
+input`` and ``done``; only the first message names the contract, so a
+continuation has to recover it from the task's history. :func:`behavior_for`
+handles both.
+
+**`acts/sut-behaviors.yaml` is the list; this module is the implementation.**
+They are separate on purpose — the YAML is what the SDK *claims*, the code is
+what it *does*, and the runner checks one against the other by running tests.
+So nothing here re-states the list: the name is read straight out of the
+message with a regex, and a prefix that reaches :func:`_dispatch` without a
+branch fails the task loudly. Keeping a second copy of the names here would
+add a way for the claim and the behaviour to drift silently, which is the one
+thing the split exists to prevent.
+
+That regex is greedy to the word boundary, which gives longest-match for
+free: `tck-artifact-file-url` beats `tck-artifact-file` without an ordered
+table, and a misspelled prefix is reported as an unimplemented behaviour
+instead of falling through to the ITK path and failing there with "no valid
+instruction".
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import uuid
+
+from typing import TYPE_CHECKING, Any
+
+import acts_client_parse
+
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct, Value
+
+from a2a.server.tasks import TaskUpdater
+from a2a.types.a2a_pb2 import Message, Part, Task, TaskState, TaskStatus
+
+
+if TYPE_CHECKING:
+    from a2a.server.agent_execution import RequestContext
+    from a2a.server.events import EventQueue
+
+
+logger = logging.getLogger(__name__)
+
+#: Every behaviour name starts with this, and it is what tells the agent an
+#: incoming message belongs to ACTS rather than to an ITK traversal.
+PREFIX = 'tck-'
+
+#: The word a multi-turn conversation ends on. Fixed by the corpus, which
+#: sends exactly this to close `CORE-MULTI-001`, `CORE-MULTI-005` and
+#: `CORE-HIST-002`.
+MULTI_TURN_DONE = 'done'
+
+#: How long `tck-long-running` stays in WORKING before completing. Short
+#: enough not to dominate a run, long enough that a test polling for a
+#: non-terminal state sees one: the corpus polls with `delay_ms: 2000` and
+#: `max_attempts: 15`.
+LONG_RUNNING_DELAY_S = 1.0
+
+#: A behaviour name: `tck-` and one or more hyphen-joined lowercase words.
+#: Greedy, so it stops at the first character that cannot be part of a name —
+#: which is what makes `tck-artifact-file-url document` yield the full name
+#: rather than `tck-artifact-file`.
+_NAME = re.compile(r'^(tck-[a-z0-9]+(?:-[a-z0-9]+)*)')
+
+
+def _first_text(message: Message | None) -> str:
+    """The first text part of a message, or ``''``."""
+    if message is None:
+        return ''
+    for part in message.parts:
+        if part.text:
+            return part.text
+    return ''
+
+
+def behavior_in(text: str) -> str | None:
+    """The behaviour named by ``text``, or ``None``.
+
+    Names an *asserted* behaviour, not necessarily an implemented one: an
+    unknown `tck-*` still routes here, and :func:`_dispatch` reports it as
+    unimplemented. That is the honest outcome — the alternative is a message
+    plainly meant for ACTS being handed to the traversal decoder.
+    """
+    match = _NAME.match(text.strip())
+    return match.group(1) if match else None
+
+
+def behavior_for(context: RequestContext) -> str | None:
+    """The behaviour this request belongs to, current message or task.
+
+    A continuation turn carries no prefix, so when the incoming message names
+    none, the task's own history is consulted — its first user message is
+    where the contract was declared.
+    """
+    named = behavior_in(_first_text(context.message))
+    if named is not None:
+        return named
+
+    task = context.current_task
+    if task is None:
+        return None
+    for historical in task.history:
+        found = behavior_in(_first_text(historical))
+        if found is not None:
+            return found
+    return None
+
+
+def is_acts_request(context: RequestContext) -> bool:
+    """Should this request be served by the ACTS contract rather than ITK?"""
+    return behavior_for(context) is not None
+
+
+def _data_part(payload: dict[str, Any]) -> Part:
+    """A data part. `Part.data` is a `Value`, not a `Struct`."""
+    struct = Struct()
+    struct.update(payload)
+    return Part(data=Value(struct_value=struct))
+
+
+async def run(
+    behavior: str,
+    context: RequestContext,
+    event_queue: EventQueue,
+) -> None:
+    """Serve one ACTS request, start to finish.
+
+    Owns the task lifecycle rather than being handed a live task, because
+    `tck-message-response` must produce **no** task at all — A2A lets an agent
+    answer with a bare `Message`, and a server that opened a task first would
+    make the response a task update instead, which is the opposite of what
+    `CORE-SEND-003` checks.
+    """
+    logger.info('ACTS behaviour %s on task %s', behavior, context.task_id)
+
+    if behavior == 'tck-message-response':
+        await event_queue.enqueue_event(
+            Message(
+                role='ROLE_AGENT',
+                message_id=str(uuid.uuid4()),
+                context_id=context.context_id or '',
+                parts=[Part(text='tck message response')],
+            )
+        )
+        return
+
+    updater = TaskUpdater(event_queue, context.task_id, context.context_id)
+
+    # A continuation turn already has a task; re-announcing it would emit a
+    # second submitted event for the same id.
+    if context.current_task is None:
+        task = Task(
+            id=context.task_id,
+            context_id=context.context_id,
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+            history=[context.message] if context.message else [],
+        )
+        async with updater._lock:  # noqa: SLF001
+            await event_queue.enqueue_event(task)
+
+    await updater.update_status(TaskState.TASK_STATE_WORKING)
+    await _dispatch(behavior, context, updater)
+
+
+async def _dispatch(
+    behavior: str,
+    context: RequestContext,
+    updater: TaskUpdater,
+) -> None:
+    """Take an already-working task to wherever the behaviour ends.
+
+    Unknown behaviours fail the task loudly rather than completing it — a
+    silent success would report conformance the agent never demonstrated.
+    """
+    if behavior == acts_client_parse.BEHAVIOR:
+        await _client_parse(context, updater)
+    elif behavior == 'tck-multi-turn':
+        await _multi_turn(context, updater)
+    elif behavior == 'tck-cancel':
+        await _cancel(context)
+    elif behavior == 'tck-long-running':
+        await _long_running(updater)
+    elif behavior in ('tck-stream-basic', 'tck-stream-chunked'):
+        await _stream(behavior, updater)
+    elif behavior.startswith('tck-artifact-'):
+        await _artifact(behavior, updater)
+    else:
+        await _terminal(behavior, updater)
+
+
+async def _cancel(context: RequestContext) -> None:
+    """Hold in WORKING until the framework cancels this executor task.
+
+    A CancelTask surfaces here as `CancelledError`. Waiting on an event
+    nobody sets is how you block indefinitely without polling.
+    """
+    try:
+        await asyncio.Event().wait()
+    except asyncio.CancelledError:
+        logger.info('tck-cancel: task %s canceled', context.task_id)
+        raise
+
+
+async def _long_running(updater: TaskUpdater) -> None:
+    """Stay in WORKING briefly, then complete with an artifact."""
+    await asyncio.sleep(LONG_RUNNING_DELAY_S)
+    # `CORE-EXEC-001` polls to completion and then asserts the finished task
+    # carries at least one artifact, so the work has to leave one behind even
+    # though §11.2 describes this behaviour only as "delayed completion".
+    await updater.add_artifact(
+        [Part(text='long running result')],
+        name='long-running',
+        last_chunk=True,
+    )
+    await updater.complete(
+        updater.new_agent_message([Part(text='long running work finished')])
+    )
+
+
+async def _terminal(behavior: str, updater: TaskUpdater) -> None:
+    """End the task in the state the behaviour names.
+
+    An unknown behaviour fails the task rather than completing it — a silent
+    success would report conformance the agent never demonstrated.
+    """
+    terminal = {
+        'tck-complete-task': updater.complete,
+        'tck-task-failure': updater.failed,
+        'tck-reject-task': updater.reject,
+        'tck-input-required': updater.requires_input,
+        'tck-auth-required': updater.requires_auth,
+    }.get(behavior)
+
+    if terminal is None:
+        await updater.failed(
+            updater.new_agent_message(
+                [Part(text=f'unimplemented ACTS behaviour {behavior!r}')]
+            )
+        )
+        return
+
+    await terminal(updater.new_agent_message([Part(text=f'{behavior} ok')]))
+
+
+async def _client_parse(context: RequestContext, updater: TaskUpdater) -> None:
+    """ACTS §10: run a canonical wire payload through this SDK's own client.
+
+    The request carries `{operation, wire_payload}` in a data part; the reply
+    carries whatever the client parsed, in the same data-part shape, so the
+    runner can assert `expect_parsed` against it exactly as it would
+    `expect.body`.
+    """
+    request = None
+    for part in context.message.parts if context.message else ():
+        if part.HasField('data'):
+            request = acts_client_parse.request_from(
+                json_format.MessageToDict(part.data)
+                if hasattr(part.data, 'DESCRIPTOR')
+                else part.data
+            )
+            if request is not None:
+                break
+
+    if request is None:
+        await updater.failed(
+            updater.new_agent_message(
+                [Part(text='tck-client-parse needs {operation, wire_payload}')]
+            )
+        )
+        return
+
+    operation, payload = request
+    parsed = await acts_client_parse.parse(operation, payload)
+    await updater.add_artifact(
+        [_data_part(parsed)], name=acts_client_parse.BEHAVIOR, last_chunk=True
+    )
+    await updater.complete(
+        updater.new_agent_message([Part(text=f'{operation} parsed')])
+    )
+
+
+async def _multi_turn(context: RequestContext, updater: TaskUpdater) -> None:
+    """INPUT_REQUIRED until the user says `done`, then COMPLETED."""
+    said = _first_text(context.message).strip().lower()
+    if said.startswith(MULTI_TURN_DONE):
+        await updater.complete(
+            updater.new_agent_message([Part(text='multi-turn complete')])
+        )
+        return
+    await updater.requires_input(
+        updater.new_agent_message([Part(text='more input please')])
+    )
+
+
+async def _artifact(behavior: str, updater: TaskUpdater) -> None:
+    """Complete with the artifact shape the behaviour names."""
+    parts = {
+        'tck-artifact-text': [Part(text='generated text content')],
+        'tck-artifact-data': [_data_part({'key': 'value', 'count': 1})],
+        'tck-artifact-file': [
+            Part(
+                raw=b'file bytes',
+                filename='document.txt',
+                media_type='text/plain',
+            )
+        ],
+        'tck-artifact-file-url': [
+            Part(
+                url='https://example.com/document.txt',
+                filename='document.txt',
+                media_type='text/plain',
+            )
+        ],
+    }[behavior]
+
+    await updater.add_artifact(parts, name=behavior, last_chunk=True)
+    await updater.complete(
+        updater.new_agent_message([Part(text=f'{behavior} ok')])
+    )
+
+
+async def _stream(behavior: str, updater: TaskUpdater) -> None:
+    """Working -> artifact(s) -> completed, as separate events.
+
+    Emitted through the updater so each step is its own queue event, which is
+    what makes them separate SSE frames — a single combined update would
+    satisfy `min_count` only by accident.
+    """
+    await updater.update_status(
+        TaskState.TASK_STATE_WORKING,
+        message=updater.new_agent_message([Part(text='streaming started')]),
+    )
+
+    if behavior == 'tck-stream-chunked':
+        artifact_id = f'{updater.task_id}-chunked'
+        chunks = ['chunk one ', 'chunk two ', 'chunk three']
+        for index, chunk in enumerate(chunks):
+            await updater.add_artifact(
+                [Part(text=chunk)],
+                artifact_id=artifact_id,
+                name='chunked',
+                append=index > 0,
+                last_chunk=index == len(chunks) - 1,
+            )
+    else:
+        await updater.add_artifact(
+            [Part(text='streamed content')], name='streamed', last_chunk=True
+        )
+
+    await updater.complete(
+        updater.new_agent_message([Part(text=f'{behavior} ok')])
+    )
diff --git a/itk/acts_client_parse.py b/itk/acts_client_parse.py
new file mode 100644
index 000000000..92b294d9a
--- /dev/null
+++ b/itk/acts_client_parse.py
@@ -0,0 +1,248 @@
+"""The `tck-client-parse` behaviour: ACTS §10 client tests.
+
+Every other ACTS step drives the SUT as a **server** — send bytes, assert on
+what comes back. A client test inverts that: it supplies a canonical wire
+payload and asks whether *this SDK's client* parses it correctly, which no A2A
+operation can ask a server. §10 defines the file format and says nothing about
+the mechanism, so the runner cannot reach the client at all and skips the
+eight `CLIENT-*` tests.
+
+This closes that gap from the agent side. The runner sends an ordinary
+`send_message` naming `tck-client-parse` with `{operation, wire_payload}` in a
+data part; the agent builds a real SDK client whose HTTP transport returns
+that payload verbatim, performs the operation, and hands back whatever its own
+client produced.
+
+**A mock transport rather than a bare deserializer.** Calling
+`SendMessageResponse.FromJson(...)` directly would be far less code and would
+prove much less: it skips the JSON-RPC envelope, the error mapping and the
+response plumbing, which is most of what a client test is about.
+`CLIENT-PARSE-004` makes that concrete — it feeds a JSON-RPC *error* envelope
+and expects the client to surface `{error: {code, message}}`. Unwrapping that
+by hand in the agent would be reimplementing the code under test.
+
+The reply is shaped like a dispatcher's `payload` — the §4.2 assertion root
+for the operation — so `expect_parsed` reads exactly like `expect.body` and
+the runner needs no special assertion path.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+from typing import Any
+
+import httpx
+
+from google.protobuf.json_format import MessageToDict
+
+from a2a.client import ClientConfig, create_client
+from a2a.client.card_resolver import A2ACardResolver
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    GetExtendedAgentCardRequest,
+    GetTaskRequest,
+    Message,
+    SendMessageRequest,
+)
+from a2a.utils import TransportProtocol
+
+
+logger = logging.getLogger(__name__)
+
+BEHAVIOR = 'tck-client-parse'
+
+#: Where the fake server lives. Nothing dials it — the mock transport answers
+#: before a socket is opened — but the client needs a syntactically valid base.
+_BASE_URL = 'http://acts-client-parse.invalid'
+
+_CARD_PATH = '/.well-known/agent-card.json'
+_EXTENDED_CARD_PATH = '/extendedAgentCard'
+
+
+def _is_enveloped(payload: Any) -> bool:
+    """Is this payload a JSON-RPC envelope rather than a bare object?"""
+    return isinstance(payload, dict) and (
+        'jsonrpc' in payload or 'result' in payload or 'error' in payload
+    )
+
+
+def _transport(payload: Any) -> httpx.MockTransport:
+    """An HTTP transport that answers every request with ``payload``.
+
+    The response's JSON-RPC ``id`` is rewritten to echo the request's, which
+    is what a real server does. The corpus's canned payloads carry a fixed id
+    (``req-001``, ``1``, …) that cannot match one the client invented at call
+    time, so a client validating the correlation — as JSON-RPC 2.0 requires —
+    rejects the payload before parsing any of it. Echoing keeps the test about
+    parsing rather than about a correlation the canned-payload model cannot
+    express.
+    """
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        body = payload
+        if _is_enveloped(payload):
+            try:
+                sent = json.loads(request.content)
+            except ValueError:
+                sent = None
+            if isinstance(sent, dict) and 'id' in sent:
+                body = {**payload, 'id': sent['id']}
+        return httpx.Response(200, json=body)
+
+    return httpx.MockTransport(handler)
+
+
+def _scaffold_card() -> AgentCard:
+    """A minimal card advertising JSON-RPC, so `create_client` can bind.
+
+    A client needs a card before it will talk to anything. Passing the card
+    object rather than a URL is what keeps the mock transport free to answer
+    with the payload under test: were the client to resolve a card over that
+    transport it would be handed the `wire_payload` instead.
+
+    JSON-RPC because that is the binding every non-card `wire_payload` in the
+    corpus is written in.
+    """
+    return AgentCard(
+        name='acts-client-parse',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=False, extended_agent_card=True
+        ),
+        supported_interfaces=[
+            AgentInterface(
+                url=_BASE_URL,
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            )
+        ],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+    )
+
+
+async def _client(payload: Any) -> Any:
+    config = ClientConfig()
+    config.streaming = False
+    config.supported_protocol_bindings = [TransportProtocol.JSONRPC]
+    config.httpx_client = httpx.AsyncClient(transport=_transport(payload))
+    return await create_client(_scaffold_card(), client_config=config)
+
+
+async def _parse_card(payload: Any, path: str) -> dict[str, Any]:
+    """Run a bare card payload through the SDK's own card handling.
+
+    Both card operations land here when the payload is a bare card, which is
+    how the corpus writes them — and correctly so: a card is fetched over
+    plain HTTP on every binding, so there is no envelope to unwrap. The two
+    differ only in the path they are served from.
+    """
+    async with httpx.AsyncClient(transport=_transport(payload)) as http:
+        resolver = A2ACardResolver(httpx_client=http, base_url=_BASE_URL)
+        card = await resolver.get_agent_card(relative_card_path=path)
+        return MessageToDict(card)
+
+
+async def _parse_extended_card_envelope(payload: Any) -> dict[str, Any]:
+    """The enveloped form of `get_extended_agent_card`, via the RPC client."""
+    async with httpx.AsyncClient(transport=_transport(payload)) as http:
+        config = ClientConfig()
+        config.streaming = False
+        config.supported_protocol_bindings = [TransportProtocol.JSONRPC]
+        config.httpx_client = http
+        client = await create_client(_scaffold_card(), client_config=config)
+        try:
+            card = await client.get_extended_agent_card(
+                GetExtendedAgentCardRequest()
+            )
+        finally:
+            await client.close()
+        return MessageToDict(card)
+
+
+async def parse(operation: str, payload: Any) -> dict[str, Any]:
+    """Feed ``payload`` to this SDK's client and return what it produced.
+
+    The result is the §4.2 assertion root for ``operation``: a
+    `SendMessageResponse` keeps its `task`/`message` discriminator, `get_task`
+    returns the Task's own fields, and a card operation returns the card.
+
+    An error the client raises comes back as ``{'error': {...}}`` rather than
+    propagating, because for `CLIENT-PARSE-004` that *is* the expected parse.
+    """
+    try:
+        parsed = await _parse_operation(operation, payload)
+    except Exception as exc:  # noqa: BLE001 - the error IS the parse result
+        return _as_error(exc, payload)
+    return parsed
+
+
+async def _parse_operation(operation: str, payload: Any) -> dict[str, Any]:
+    """Route ``operation`` to whichever half of the client handles it."""
+    if operation == 'get_agent_card':
+        return await _parse_card(payload, _CARD_PATH)
+
+    if operation == 'get_extended_agent_card':
+        # The corpus writes this one as a bare card, matching the wire:
+        # `supportedInterfaces` on its own payload names REST, where the
+        # extended card is a plain GET. Accept an envelope too, since a
+        # JSON-RPC binding does wrap it.
+        if _is_enveloped(payload):
+            return await _parse_extended_card_envelope(payload)
+        return await _parse_card(payload, _EXTENDED_CARD_PATH)
+
+    return await _parse_via_rpc(operation, payload)
+
+
+async def _parse_via_rpc(operation: str, payload: Any) -> dict[str, Any]:
+    """The operations that go through the RPC client rather than the card."""
+    client = await _client(payload)
+    try:
+        if operation == 'send_message':
+            async for event in client.send_message(
+                SendMessageRequest(
+                    message=Message(role='ROLE_USER', message_id='acts')
+                )
+            ):
+                # StreamResponse keeps the oneof, which is exactly the
+                # discriminator `expect_parsed: {task: ...}` addresses.
+                return MessageToDict(event)
+            return {}
+        if operation == 'get_task':
+            task = await client.get_task(GetTaskRequest(id='acts'))
+            return MessageToDict(task)
+    finally:
+        await client.close()
+
+    return {'error': {'message': f'unsupported client operation {operation!r}'}}
+
+
+def _as_error(exc: Exception, payload: Any) -> dict[str, Any]:
+    """Render a client-raised error the way `expect_parsed` addresses it.
+
+    `CLIENT-PARSE-004` asserts `error.code` and `error.message`. An SDK error
+    object does not necessarily carry the JSON-RPC code, so the envelope's own
+    `error` is preferred when the payload had one — the assertion is about the
+    client having surfaced *that* error, and inventing a code here would pass
+    the test without the client having done anything.
+    """
+    if isinstance(payload, dict) and isinstance(payload.get('error'), dict):
+        return {'error': dict(payload['error']), 'raised': type(exc).__name__}
+    return {'error': {'message': str(exc)}, 'raised': type(exc).__name__}
+
+
+def request_from(part_data: Any) -> tuple[str, Any] | None:
+    """Read `{operation, wire_payload}` out of the step's data part."""
+    if not isinstance(part_data, dict):
+        return None
+    operation = part_data.get('operation')
+    if not isinstance(operation, str):
+        return None
+    return operation, part_data.get('wire_payload')
+
+
+__all__ = ['BEHAVIOR', 'parse', 'request_from']
diff --git a/itk/main.py b/itk/main.py
new file mode 100644
index 000000000..6b762ee3d
--- /dev/null
+++ b/itk/main.py
@@ -0,0 +1,847 @@
+import argparse  # noqa: I001
+import asyncio
+import base64
+import logging
+import os
+import signal
+import uuid
+
+import grpc
+import httpx
+import uvicorn
+
+from fastapi import FastAPI
+from starlette.middleware.base import (
+    BaseHTTPMiddleware,
+    RequestResponseEndpoint,
+)
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.types import ASGIApp
+from typing import Any
+
+from pyproto import instruction_pb2
+
+import acts_behaviors
+
+from a2a.client import Client, ClientConfig, create_client
+from a2a.client.errors import A2AClientError
+from a2a.compat.v0_3 import a2a_v0_3_pb2_grpc
+from a2a.compat.v0_3.grpc_handler import CompatGrpcHandler
+from a2a.compat.v0_3.types import Role as LegacyRole
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.routes import (
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler, GrpcHandler
+from a2a.server.tasks import (
+    TaskUpdater,
+    BasePushNotificationSender,
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import Role, a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    CancelTaskRequest,
+    HTTPAuthSecurityScheme,
+    Message,
+    Part,
+    SecurityRequirement,
+    SecurityScheme,
+    SendMessageRequest,
+    StringList,
+    SubscribeToTaskRequest,
+    Task,
+    TaskState,
+    TaskStatus,
+    TaskPushNotificationConfig,
+)
+from a2a.utils import TransportProtocol
+
+log_level_str = os.environ.get('ITK_LOG_LEVEL', 'INFO').upper()
+log_level = getattr(logging, log_level_str, logging.INFO)
+logging.basicConfig(level=log_level)
+logger = logging.getLogger(__name__)
+
+
+def extract_instruction(
+    message: Message | None,
+) -> instruction_pb2.Instruction | None:
+    """Extracts an Instruction proto from an A2A Message."""
+    if not message or not message.parts:
+        return None
+
+    for part in message.parts:
+        # 1. Handle binary protobuf part (media_type or filename)
+        if (
+            part.media_type == 'application/x-protobuf'
+            or part.filename == 'instruction.bin'
+        ):
+            try:
+                inst = instruction_pb2.Instruction()
+                if part.raw:
+                    inst.ParseFromString(part.raw)
+                elif part.text:
+                    # Some clients might send it as base64 in text part
+                    raw = base64.b64decode(part.text)
+                    inst.ParseFromString(raw)
+            except Exception:
+                logger.debug(
+                    'Failed to parse instruction from binary part',
+                    exc_info=True,
+                )
+                continue
+            else:
+                return inst
+
+        # 2. Handle base64 encoded instruction in any text part
+        if part.text:
+            try:
+                raw = base64.b64decode(part.text)
+                inst = instruction_pb2.Instruction()
+                inst.ParseFromString(raw)
+            except Exception:
+                logger.debug(
+                    'Failed to parse instruction from text part', exc_info=True
+                )
+                continue
+            else:
+                return inst
+
+    return None
+
+
+def _get_text_from_part(part: Any) -> str | None:
+    """Safely extracts text string from a Part object supporting protobuf, pydantic, and raw dict."""
+    if not part:
+        return None
+    if hasattr(part, 'HasField') and part.HasField('text'):
+        return part.text
+    root = getattr(part, 'root', part)
+    if isinstance(root, dict):
+        return root.get('text')
+    return getattr(root, 'text', None)
+
+
+def _extract_text_from_event(event: Any) -> list[str]:
+    """Extracts text parts from an event's message."""
+    if isinstance(event, tuple):
+        results = []
+        for item in event:
+            results.extend(_extract_text_from_event(item))
+        return results
+
+    message = None
+    if hasattr(event, 'HasField'):
+        if event.HasField('message'):
+            message = event.message
+        elif event.HasField('task') and event.task.status.HasField('message'):
+            message = event.task.status.message
+        elif event.HasField(
+            'status_update'
+        ) and event.status_update.status.HasField('message'):
+            message = event.status_update.status.message
+
+    results = []
+    if message:
+        results.extend(part.text for part in message.parts if part.text)
+    return results
+
+
+async def _handle_call_agent_with_resubscribe(  # noqa: PLR0912, PLR0915
+    client: Client, request: SendMessageRequest
+) -> list[str]:
+    """Handles the send-disconnect-resubscribe flow."""
+    results = []
+    logger.info('Executing re-subscribe behavior')
+    agen = client.send_message(request)
+    task_id = None
+
+    async for event in agen:
+        logger.info('Event before disconnect: %s', event)
+        if event.HasField('task'):
+            task_id = event.task.id
+        elif event.HasField('status_update'):
+            task_id = event.status_update.task_id
+        break
+
+    await agen.aclose()
+    logger.info('Disconnected from task %s. Now re-subscribing.', task_id)
+
+    resub_agen = client.subscribe(SubscribeToTaskRequest(id=task_id))
+
+    task_obj = None
+    finished = False
+    async for event in resub_agen:
+        logger.info('Event after re-subscribe: %s', event)
+        if isinstance(event, Task):
+            task_obj = event
+        elif hasattr(event, 'HasField') and event.HasField('task'):
+            task_obj = event.task
+
+        if task_obj and hasattr(task_obj, 'history'):
+            for msg in task_obj.history:
+                if msg.role in (
+                    Role.ROLE_AGENT,
+                    LegacyRole.agent,
+                    'ROLE_AGENT',
+                ):
+                    for part in msg.parts:
+                        text = _get_text_from_part(part)
+                        if text and 'task-finished' in text:
+                            logger.info(
+                                'Found task-finished in history, breaking loop!'
+                            )
+                            results.append(text.replace('task-finished', ''))
+                            finished = True
+                            break
+                if finished:
+                    break
+        if finished:
+            break
+
+        extracted_text = _extract_text_from_event(event)
+        for text in extracted_text:
+            processed_text = text.replace('task-finished', '')
+            results.append(processed_text)
+        if any('task-finished' in text for text in extracted_text):
+            logger.info(
+                'Received task-finished after re-subscribe, breaking loop.'
+            )
+            finished = True
+            break
+
+    if not results and task_obj and hasattr(task_obj, 'history'):
+        logger.info('Results empty after loop, reading from history.')
+        for msg in task_obj.history:
+            # Check role using SDK schemas for v1.0 (protobuf enum Role.ROLE_AGENT)
+            # and v0.3 (pydantic enum LegacyRole.agent), as well as string forms.
+            if msg.role in (Role.ROLE_AGENT, LegacyRole.agent, 'ROLE_AGENT'):
+                for part in msg.parts:
+                    text = _get_text_from_part(part)
+                    if text:
+                        results.append(text.replace('task-finished', ''))
+
+    if not finished:
+        logger.info('Canceling task %s after retrieval.', task_id)
+        try:
+            await client.cancel_task(CancelTaskRequest(id=task_id))
+            logger.info('Task cancelled successfully: %s', task_id)
+        except A2AClientError:
+            logger.exception('Failed to cancel task %s', task_id)
+            raise
+
+    return results
+
+
+def wrap_instruction_to_request(inst: instruction_pb2.Instruction) -> Message:
+    """Wraps an Instruction proto into an A2A Message."""
+    inst_bytes = inst.SerializeToString()
+    return Message(
+        role='ROLE_USER',
+        message_id=str(uuid.uuid4()),
+        parts=[
+            Part(
+                raw=inst_bytes,
+                media_type='application/x-protobuf',
+                filename='instruction.bin',
+            )
+        ],
+    )
+
+
+async def handle_call_agent(
+    call: instruction_pb2.CallAgent,
+) -> list[str]:
+    """Handles the CallAgent instruction by invoking another agent."""
+    logger.info('Calling agent %s via %s', call.agent_card_uri, call.transport)
+
+    # Mapping transport string to TransportProtocol enum
+    transport_map = {
+        'JSONRPC': TransportProtocol.JSONRPC,
+        'HTTP+JSON': TransportProtocol.HTTP_JSON,
+        'HTTP_JSON': TransportProtocol.HTTP_JSON,
+        'REST': TransportProtocol.HTTP_JSON,
+        'GRPC': TransportProtocol.GRPC,
+    }
+
+    selected_transport = transport_map.get(
+        call.transport.upper(), TransportProtocol.JSONRPC
+    )
+    if selected_transport is None:
+        raise ValueError(f'Unsupported transport: {call.transport}')
+
+    config = ClientConfig()
+    config.grpc_channel_factory = grpc.aio.insecure_channel
+    config.supported_protocol_bindings = [selected_transport]
+    config.streaming = call.streaming or (
+        selected_transport == TransportProtocol.GRPC
+    )
+
+    if call.HasField('resubscribe') and not config.streaming:
+        raise ValueError('Re-subscription requires streaming to be enabled')
+
+    if call.HasField('push_notification'):
+        url = call.push_notification.url
+        if not url:
+            raise ValueError('URL not specified in push_notification behavior')
+        if not url.startswith(('http://', 'https://')):
+            url = f'http://{url}'
+        config.push_notification_config = TaskPushNotificationConfig(
+            url=f'{url}/notifications',
+            token='itk-token',  # noqa: S106
+        )
+
+    async with httpx.AsyncClient(timeout=30.0) as httpx_client:
+        config.httpx_client = httpx_client
+        try:
+            client = await create_client(
+                call.agent_card_uri,
+                client_config=config,
+            )
+
+            # Wrap nested instruction
+            nested_msg = wrap_instruction_to_request(call.instruction)
+            request = SendMessageRequest(message=nested_msg)
+
+            results = []
+
+            if call.HasField('resubscribe'):
+                results.extend(
+                    await _handle_call_agent_with_resubscribe(client, request)
+                )
+            else:
+                async for event in client.send_message(request):
+                    logger.info('Event: %s', event)
+                    results.extend(_extract_text_from_event(event))
+
+        except Exception as e:
+            logger.exception('Failed to call outbound agent')
+            raise RuntimeError(
+                f'Outbound call to {call.agent_card_uri} failed: {e!s}'
+            ) from e
+        else:
+            return results
+
+
+def _should_hold(inst: instruction_pb2.Instruction) -> bool:
+    """Recursively checks if any part of the instruction requests holding the task."""
+    if inst.HasField('return_response') and inst.return_response.hold_task:
+        return True
+    if inst.HasField('steps'):
+        return any(_should_hold(step) for step in inst.steps.instructions)
+    return False
+
+
+async def handle_instruction(
+    inst: instruction_pb2.Instruction,
+) -> list[str]:
+    """Recursively handles instructions."""
+    if inst.HasField('call_agent'):
+        return await handle_call_agent(inst.call_agent)
+    if inst.HasField('return_response'):
+        return [inst.return_response.response]
+    if inst.HasField('steps'):
+        all_results = []
+        for step in inst.steps.instructions:
+            results = await handle_instruction(step)
+            all_results.extend(results)
+        return all_results
+    raise ValueError('Unknown instruction type')
+
+
+class V10AgentExecutor(AgentExecutor):
+    """Executor for ITK v10 agent tasks."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Executes a task instruction."""
+        logger.info('Executing task %s', context.task_id)
+
+        # Dual mode. An ACTS conformance test names a `tck-*` behaviour in its
+        # first user message (ACTS §11); anything else is an ITK traversal
+        # carrying a protobuf Instruction. The branch is taken before any task
+        # is created, because one ACTS behaviour must answer with a bare
+        # Message and so must not open a task at all.
+        behavior = acts_behaviors.behavior_for(context)
+        if behavior is not None:
+            await acts_behaviors.run(behavior, context, event_queue)
+            return
+
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+
+        # Explicitly create the task by sending it to the queue
+        task = Task(
+            id=context.task_id,
+            context_id=context.context_id,
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+            history=[context.message] if context.message else [],
+        )
+        async with task_updater._lock:  # noqa: SLF001
+            await event_queue.enqueue_event(task)
+
+        await task_updater.update_status(TaskState.TASK_STATE_WORKING)
+
+        instruction = extract_instruction(context.message)
+        if not instruction:
+            error_msg = 'No valid instruction found in request'
+            logger.error(error_msg)
+            await task_updater.update_status(
+                TaskState.TASK_STATE_FAILED,
+                message=task_updater.new_agent_message([Part(text=error_msg)]),
+            )
+            return
+
+        should_hold_task = _should_hold(instruction)
+
+        try:
+            logger.info('Instruction: %s', instruction)
+            results = await handle_instruction(instruction)
+
+            response_text = '\n'.join(results)
+            logger.info('Response: %s', response_text)
+
+            if should_hold_task:
+                logger.info('Holding task %s as requested', context.task_id)
+                # Emitted event: response + task-finished
+                logger.info(
+                    'Emitting response and task-finished for held task %s',
+                    context.task_id,
+                )
+                await task_updater.update_status(
+                    TaskState.TASK_STATE_WORKING,
+                    message=task_updater.new_agent_message(
+                        [Part(text=response_text + '\n' + 'task-finished')]
+                    ),
+                )
+                await asyncio.sleep(2)
+
+                # Continue emitting "task-finished" every 2 seconds
+                try:
+                    while True:
+                        logger.info(
+                            'Emitting periodic status update for held task %s',
+                            context.task_id,
+                        )
+                        await task_updater.update_status(
+                            TaskState.TASK_STATE_WORKING,
+                            message=None,
+                        )
+                        await asyncio.sleep(2)
+                except asyncio.CancelledError:
+                    logger.info('Task %s cancelled', context.task_id)
+                    return
+            else:
+                await task_updater.update_status(
+                    TaskState.TASK_STATE_COMPLETED,
+                    message=task_updater.new_agent_message(
+                        [Part(text=response_text)]
+                    ),
+                )
+                logger.info('Task %s completed', context.task_id)
+        except Exception:
+            logger.exception('Error during instruction handling')
+            await task_updater.update_status(
+                TaskState.TASK_STATE_FAILED,
+                message=None,
+            )
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Cancels a task."""
+        logger.info('Cancel requested for task %s', context.task_id)
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+        await task_updater.update_status(TaskState.TASK_STATE_CANCELED)
+
+
+#: Credentials the ACTS runner presents. Not secrets: the runner attaches the
+#: valid one to every abstract operation and offers the insufficient one from
+#: `SEC-AUTH-002` and `SEC-EXTCARD-002`, so a fixture has to recognise both to
+#: answer 200 / 403 / 401 as those tests require.
+ACTS_VALID_TOKEN = 'itk-valid-token'  # noqa: S105
+ACTS_INSUFFICIENT_TOKEN = 'itk-insufficient-token'  # noqa: S105
+ACTS_SECURITY_SCHEME = 'bearerAuth'
+
+#: Where the REST binding serves the extended card, relative to its mount.
+#: Matched as a suffix because `create_rest_routes` also mounts every route
+#: under `/{tenant}`, so the same operation answers on two paths.
+EXTENDED_CARD_PATH = '/extendedAgentCard'
+
+
+def _auth_enforced() -> bool:
+    """Whether to require a credential on the ordinary operation endpoints.
+
+    Off unless `ITK_ACTS_AUTH` is set. Two reasons, and the second decides it:
+
+    - ITK traversal peers dial this agent with no credential at all, so
+      enforcing during a traversal run would fail every scenario that calls
+      us. An environment switch alone would handle that, since the two suites
+      run as separate processes.
+    - The ACTS runner attaches its credential to *abstract operations only*;
+      raw steps are sent exactly as written (ACTS §4.4), which is what keeps
+      the unauthenticated `SEC-AUTH-001` probe meaningful. But then every
+      other raw step is unauthenticated too, and fifteen of them expect to
+      succeed. An absent `Authorization` header means "reject me" in
+      `SEC-AUTH-001` and "serve me" in `JSONRPC-ENV-001`, and no server can
+      tell those two requests apart.
+
+    So the ACTS runner sets this for a *separate* pass over just the
+    `SEC-AUTH-*` tests, the same way `ITK_ACTS_REDUCED_CAPABILITIES` gets its
+    own pass, and leaves the main pass unauthenticated. With the switch off
+    the card declares no schemes — which is honest, and makes those tests skip
+    on their `authentication` precondition rather than fail.
+
+    The extended-card endpoint is *not* covered by this switch; see
+    `_ActsCredentialMiddleware`.
+    """
+    return bool(os.environ.get('ITK_ACTS_AUTH'))
+
+
+def _security_schemes() -> dict[str, SecurityScheme]:
+    """The schemes the card advertises.
+
+    Declared only when the agent actually enforces them: a card claiming a
+    scheme it does not check would be a lie, and this is what the ACTS
+    `authentication` precondition reads to decide whether the `SEC-AUTH-*`
+    tests are applicable at all.
+    """
+    if not _auth_enforced():
+        return {}
+    return {
+        ACTS_SECURITY_SCHEME: SecurityScheme(
+            http_auth_security_scheme=HTTPAuthSecurityScheme(
+                description='Bearer token presented by the ACTS runner.',
+                scheme='Bearer',
+                bearer_format='opaque',
+            )
+        )
+    }
+
+
+def _security_requirements() -> list[SecurityRequirement]:
+    """What the card says a client must satisfy.
+
+    Separate from the schemes because they mean different things: schemes are
+    what a client *may* use, requirements are what it *must*. An agent
+    publishing the first and not the second requires nothing.
+    """
+    if not _auth_enforced():
+        return []
+    return [SecurityRequirement(schemes={ACTS_SECURITY_SCHEME: StringList()})]
+
+
+def _status_body(code: int, status: str, message: str) -> dict[str, Any]:
+    """A `google.rpc.Status` body, the shape A2A §11.6 requires of an error."""
+    return {
+        'error': {
+            'code': code,
+            'status': status,
+            'message': message,
+            'details': [
+                {
+                    '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                    'reason': status,
+                    'domain': 'a2a-protocol.org',
+                }
+            ],
+        }
+    }
+
+
+def _credential_rejection(request: Request) -> JSONResponse | None:
+    """The response refusing this request, or None to let it through.
+
+    Three outcomes, because the tests distinguish them: the valid token
+    passes, the insufficient one authenticates but does not authorize (403),
+    and anything else — including nothing at all — fails authentication (401).
+    The `WWW-Authenticate` challenge is what A2A §3.3.2 asks for on the 401.
+    """
+    header = request.headers.get('authorization', '')
+    presented = ''
+    scheme, _, value = header.partition(' ')
+    if scheme.lower() == 'bearer':
+        presented = value.strip()
+
+    if presented == ACTS_VALID_TOKEN:
+        return None
+    if presented == ACTS_INSUFFICIENT_TOKEN:
+        return JSONResponse(
+            _status_body(
+                403, 'PERMISSION_DENIED', 'Token lacks the required scope.'
+            ),
+            status_code=403,
+        )
+    return JSONResponse(
+        _status_body(401, 'UNAUTHENTICATED', 'A bearer token is required.'),
+        status_code=401,
+        headers={
+            'WWW-Authenticate': (
+                f'Bearer realm="a2a", scheme="{ACTS_SECURITY_SCHEME}"'
+            )
+        },
+    )
+
+
+class _ActsCredentialMiddleware(BaseHTTPMiddleware):
+    """Guards a binding's operations, and always guards the extended card.
+
+    The extended card is guarded whatever `ITK_ACTS_AUTH` says, for two
+    reasons. It costs traversal nothing — no traversal scenario fetches one —
+    and A2A §13.3 makes it unconditional: the operation MUST require
+    authentication, whether or not the agent requires it anywhere else. That
+    is why `SEC-EXTCARD-001/002/004` are the only auth tests that can produce
+    a verdict against a default SUT.
+
+    The public agent card is not reachable through this middleware: it is
+    served from the parent app, not from either binding's mount. It has to
+    stay open — A2A §8.2 makes the well-known URL the discovery mechanism and
+    §7.3 has the client learn which schemes it needs *from that card*, so
+    requiring one to read it would be circular, and the ITK readiness probe
+    fetches it unauthenticated.
+    """
+
+    def __init__(self, app: ASGIApp, *, guard_all: bool) -> None:
+        super().__init__(app)
+        self._guard_all = guard_all
+
+    async def dispatch(
+        self, request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        guarded = self._guard_all or request.url.path.endswith(
+            EXTENDED_CARD_PATH
+        )
+        if not guarded:
+            return await call_next(request)
+        rejection = _credential_rejection(request)
+        if rejection is not None:
+            return rejection
+        return await call_next(request)
+
+
+def _capabilities() -> AgentCapabilities:
+    """What this agent advertises — everything, unless asked for less.
+
+    Four ACTS tests assert that an agent *without* a capability answers
+    `UnsupportedOperationError`, so their preconditions require the card not
+    to advertise it and they can never run against a fully capable agent. The
+    ACTS runner starts a second SUT with `ITK_ACTS_REDUCED_CAPABILITIES` set
+    to reach them, and the SDK already gates those operations on this card, so
+    publishing less is all it takes to refuse them.
+    """
+    if os.environ.get('ITK_ACTS_REDUCED_CAPABILITIES'):
+        logger.info('Advertising no optional capabilities (ACTS reduced pass)')
+        return AgentCapabilities(
+            streaming=False,
+            push_notifications=False,
+            extended_agent_card=False,
+        )
+    return AgentCapabilities(
+        streaming=True,
+        push_notifications=True,
+        extended_agent_card=True,
+    )
+
+
+async def main_async(http_port: int, grpc_port: int) -> None:
+    """Starts the Agent with HTTP and gRPC interfaces."""
+    interfaces = [
+        AgentInterface(
+            protocol_binding=TransportProtocol.GRPC,
+            url=f'127.0.0.1:{grpc_port}',
+            protocol_version='1.0',
+        ),
+        AgentInterface(
+            protocol_binding=TransportProtocol.GRPC,
+            url=f'127.0.0.1:{grpc_port}',
+            protocol_version='0.3',
+        ),
+    ]
+
+    interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.JSONRPC,
+            url=f'http://127.0.0.1:{http_port}/jsonrpc/',
+            protocol_version='1.0',
+        )
+    )
+    interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.JSONRPC,
+            url=f'http://127.0.0.1:{http_port}/jsonrpc/',
+            protocol_version='0.3',
+        )
+    )
+    interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.HTTP_JSON,
+            url=f'http://127.0.0.1:{http_port}/rest/',
+            protocol_version='1.0',
+        )
+    )
+    interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.HTTP_JSON,
+            url=f'http://127.0.0.1:{http_port}/rest/',
+            protocol_version='0.3',
+        )
+    )
+
+    agent_card = AgentCard(
+        name='ITK v10 Agent',
+        description='Python agent using SDK 1.0.',
+        version='1.0.0',
+        # ACTS evaluates a test's `preconditions` against this card and skips
+        # when they are unmet (ACTS §12.5), so anything the agent really does
+        # has to be advertised or the matching tests silently never run.
+        capabilities=_capabilities(),
+        # Authentication is *not* a capability — `AgentCapabilities` has no
+        # member for it — so it is declared here, at the top level, and the
+        # ACTS `authentication` precondition reads both of these.
+        security_schemes=_security_schemes(),
+        security_requirements=_security_requirements(),
+        # application/x-protobuf because the ITK instruction envelope is a
+        # binary Part: wrap_instruction_to_request() builds one and
+        # extract_instruction() reads it. The agent has always accepted
+        # those; declaring text/plain alone was a card that understated
+        # what it takes, which went unnoticed until validate_input_modes
+        # below started holding the agent to it.
+        default_input_modes=['text/plain', 'application/x-protobuf'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=interfaces,
+        skills=[
+            AgentSkill(
+                id='acts-behaviors',
+                name='ACTS behaviours',
+                description='Implements the ACTS §11 tck-* behaviour contract.',
+                tags=['acts', 'conformance'],
+            )
+        ],
+    )
+
+    task_store = InMemoryTaskStore()
+    push_config_store = InMemoryPushNotificationConfigStore()
+    httpx_client = httpx.AsyncClient()
+    push_sender = BasePushNotificationSender(
+        httpx_client=httpx_client,
+        config_store=push_config_store,
+    )
+
+    # One handler for every binding. It carries `extended_agent_card` because
+    # the card advertises `extendedAgentCard: true`, and a capability is
+    # advertised per agent, not per binding — configuring it on JSON-RPC alone
+    # made `Get Extended Agent Card` answer with the card over JSON-RPC and
+    # `ExtendedAgentCardNotConfiguredError` over gRPC and REST, from an agent
+    # claiming the capability once for all three.
+    handler = DefaultRequestHandler(
+        agent_executor=V10AgentExecutor(),
+        agent_card=agent_card,
+        task_store=task_store,
+        queue_manager=InMemoryQueueManager(),
+        push_config_store=push_config_store,
+        push_sender=push_sender,
+        extended_agent_card=agent_card,
+        # CORE-SEND-004 sends a part whose mediaType the card does not
+        # declare and expects ContentTypeNotSupportedError. Off by default in
+        # the SDK; this card states its input modes accurately, so the
+        # fixture can hold the SDK to them.
+        validate_input_modes=True,
+    )
+
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/.well-known/agent-card.json'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler,
+        rpc_url='/',
+        enable_v0_3_compat=True,
+    )
+    rest_routes = create_rest_routes(
+        request_handler=handler,
+        enable_v0_3_compat=True,
+    )
+
+    # Each binding is its own sub-app, so the credential guard goes on the
+    # sub-app rather than on a path prefix of the parent: the public card is
+    # served from the parent alone and must stay reachable without one.
+    jsonrpc_app = FastAPI(routes=jsonrpc_routes)
+    rest_app = FastAPI(routes=rest_routes)
+    if _auth_enforced():
+        logger.info('Requiring a bearer credential on /jsonrpc and /rest')
+        jsonrpc_app.add_middleware(_ActsCredentialMiddleware, guard_all=True)
+    # Always on for REST, whatever the mode: `/extendedAgentCard` lives here
+    # and A2A §13.3 makes its authentication unconditional.
+    rest_app.add_middleware(
+        _ActsCredentialMiddleware, guard_all=_auth_enforced()
+    )
+
+    app = FastAPI()
+    app.mount('/jsonrpc', jsonrpc_app)
+    app.mount('/rest', rest_app)
+    app.routes.extend(agent_card_routes)
+
+    server = grpc.aio.server()
+
+    compat_servicer = CompatGrpcHandler(handler)
+    a2a_v0_3_pb2_grpc.add_A2AServiceServicer_to_server(compat_servicer, server)
+    servicer = GrpcHandler(handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+
+    server.add_insecure_port(f'127.0.0.1:{grpc_port}')
+    await server.start()
+
+    logger.info(
+        'Starting ITK v10 Agent on HTTP port %s and gRPC port %s',
+        http_port,
+        grpc_port,
+    )
+
+    config = uvicorn.Config(
+        app, host='127.0.0.1', port=http_port, log_level=log_level_str.lower()
+    )
+    uvicorn_server = uvicorn.Server(config)
+
+    # Signal handling
+    loop = asyncio.get_running_loop()
+
+    async def shutdown() -> None:
+        logger.info('Shutting down...')
+        uvicorn_server.should_exit = True
+        await server.stop(5)
+        await httpx_client.aclose()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown()))
+
+    await uvicorn_server.serve()
+
+
+def main() -> None:
+    """Main entry point for the agent."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--httpPort', type=int, default=10102)
+    parser.add_argument('--grpcPort', type=int, default=11002)
+    args = parser.parse_args()
+
+    asyncio.run(main_async(args.httpPort, args.grpcPort))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/itk/pyproject.toml b/itk/pyproject.toml
new file mode 100644
index 000000000..f8dfa8e7d
--- /dev/null
+++ b/itk/pyproject.toml
@@ -0,0 +1,24 @@
+[project]
+name = "itk-python-v10-agent"
+version = "0.1.0"
+description = "ITK Python v1.0 Agent"
+dependencies = [
+    "a2a-sdk[sqlite,grpc,http-server]",
+    "fastapi",
+    "uvicorn",
+    "grpcio",
+    "grpcio-tools",
+    "protobuf",
+    "sse-starlette",
+    "httpx-sse",
+    "packaging",
+]
+
+[tool.uv]
+package = false
+
+[tool.uv.sources]
+# Resolved from the workspace root (../pyproject.toml declares this dir a
+# member), so the whole repo shares one uv.lock instead of this agent
+# keeping a second lock that drifts when a root dependency changes.
+a2a-sdk = { workspace = true }
diff --git a/itk/run_itk.sh b/itk/run_itk.sh
new file mode 100755
index 000000000..79f9d3c15
--- /dev/null
+++ b/itk/run_itk.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+# ITK harness for a2a-python — a thin shim over a2a-itk's shared driver.
+#
+# Everything that used to live here (clone, image build, container start,
+# readiness poll, POST /run, result reporting, nightly metrics) is now in
+# a2a-itk/scripts/run_itk_shared.sh, which all five SDK repos share. Only the
+# genuinely python-specific part stays: generating the proto stubs.
+#
+# Scenarios come from the shared role-based set in a2a-itk rather than a
+# scenarios.json in this repo — see a2a-itk/scenarios/traversal/.
+set -e
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+ITK_SDK_NAME=python
+ITK_SCENARIO_SET=shared
+
+itk_generate_protos() {
+  mkdir -p pyproto
+  touch pyproto/__init__.py
+  uv run --with grpcio-tools python -m grpc_tools.protoc \
+      -I. \
+      --python_out=pyproto \
+      --grpc_python_out=pyproto \
+      instruction.proto
+  # Generated code imports its sibling as a top-level module; make it relative
+  # so `pyproto` works as a package.
+  sed -i 's/^import instruction_pb2 as instruction__pb2/from . import instruction_pb2 as instruction__pb2/' \
+      pyproto/instruction_pb2_grpc.py
+}
+
+itk_extra_cleanup() {
+  rm -rf pyproto
+}
+
+# --- bootstrap -------------------------------------------------------------
+# The shared driver lives in a2a-itk, so the checkout has to exist before it
+# can be sourced. CI has already placed it here via actions/checkout; locally
+# we clone it from a2aproject/a2a-itk.
+: "${A2A_ITK_REVISION:?A2A_ITK_REVISION environment variable must be set}"
+if [ ! -d a2a-itk ]; then
+  git clone https://github.com/a2aproject/a2a-itk.git a2a-itk
+  git -C a2a-itk checkout "$A2A_ITK_REVISION"
+fi
+
+source a2a-itk/scripts/run_itk_shared.sh
diff --git a/noxfile.py b/noxfile.py
deleted file mode 100644
index 4d8b3165c..000000000
--- a/noxfile.py
+++ /dev/null
@@ -1,144 +0,0 @@
-# pylint: skip-file
-# type: ignore
-# -*- coding: utf-8 -*-
-#
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import pathlib
-import subprocess
-
-import nox
-
-
-DEFAULT_PYTHON_VERSION = '3.13'
-
-CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute()
-
-nox.options.sessions = [
-    'format',
-]
-
-# Error if a python version is missing
-nox.options.error_on_missing_interpreters = True
-
-
-@nox.session(python=DEFAULT_PYTHON_VERSION)
-def format(session):
-    """Format Python code using autoflake, pyupgrade, and ruff."""
-    # Sort Spelling Allowlist
-    spelling_allow_file = '.github/actions/spelling/allow.txt'
-
-    with open(spelling_allow_file, encoding='utf-8') as file:
-        unique_words = sorted(set(file))
-
-    with open(spelling_allow_file, 'w', encoding='utf-8') as file:
-        file.writelines(unique_words)
-
-    format_all = False
-
-    if format_all:
-        lint_paths_py = ['.']
-    else:
-        target_branch = 'origin/main'
-
-        unstaged_files = subprocess.run(
-            [
-                'git',
-                'diff',
-                '--name-only',
-                '--diff-filter=ACMRTUXB',
-                target_branch,
-            ],
-            stdout=subprocess.PIPE,
-            text=True,
-            check=False,
-        ).stdout.splitlines()
-
-        staged_files = subprocess.run(
-            [
-                'git',
-                'diff',
-                '--cached',
-                '--name-only',
-                '--diff-filter=ACMRTUXB',
-                target_branch,
-            ],
-            stdout=subprocess.PIPE,
-            text=True,
-            check=False,
-        ).stdout.splitlines()
-
-        committed_files = subprocess.run(
-            [
-                'git',
-                'diff',
-                'HEAD',
-                target_branch,
-                '--name-only',
-                '--diff-filter=ACMRTUXB',
-            ],
-            stdout=subprocess.PIPE,
-            text=True,
-            check=False,
-        ).stdout.splitlines()
-
-        changed_files = sorted(
-            {
-                file
-                for file in (unstaged_files + staged_files + committed_files)
-                if os.path.isfile(file)
-            }
-        )
-
-        lint_paths_py = [f for f in changed_files if f.endswith('.py')]
-
-        if not lint_paths_py:
-            session.log('No changed Python files to lint.')
-            return
-
-    session.install(
-        'types-requests',
-        'pyupgrade',
-        'autoflake',
-        'ruff',
-    )
-
-    if lint_paths_py:
-        if not format_all:
-            session.run(
-                'pyupgrade',
-                '--exit-zero-even-if-changed',
-                '--py311-plus',
-                *lint_paths_py,
-            )
-        session.run(
-            'autoflake',
-            '-i',
-            '-r',
-            '--remove-all-unused-imports',
-            *lint_paths_py,
-        )
-        session.run(
-            'ruff',
-            'check',
-            '--fix-only',
-            *lint_paths_py,
-        )
-        session.run(
-            'ruff',
-            'format',
-            *lint_paths_py,
-        )
diff --git a/pyproject.toml b/pyproject.toml
index fa629a2f5..23590e6a2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,48 +1,373 @@
 [project]
 name = "a2a-sdk"
-version = "0.2.0"
+dynamic = ["version"]
 description = "A2A Python SDK"
 readme = "README.md"
-requires-python = ">=3.13"
+license = "Apache-2.0"
+authors = [{ name = "Google LLC", email = "googleapis-packages@google.com" }]
+requires-python = ">=3.10"
+keywords = ["A2A", "A2A SDK", "A2A Protocol", "Agent2Agent", "Agent 2 Agent"]
 dependencies = [
-    "httpx>=0.28.1",
-    "httpx-sse>=0.4.0",
-    "opentelemetry-api>=1.33.0",
-    "opentelemetry-sdk>=1.33.0",
-    "pydantic>=2.11.3",
-    "sse-starlette>=2.3.3",
-    "starlette>=0.46.2",
-    "typing-extensions>=4.13.2",
+  "httpx>=0.28.1",
+  "pydantic>=2.11.3",
+  "protobuf>=5.29.5",
+  "google-api-core>=1.26.0",
+  "json-rpc>=1.15.0",
+  "googleapis-common-protos>=1.70.0",
+  "culsans>=0.11.0 ; python_full_version < '3.13'",
+  "packaging>=24.0",
 ]
 
+classifiers = [
+  "Intended Audience :: Developers",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "License :: OSI Approved :: Apache Software License",
+]
+
+[project.optional-dependencies]
+http-server = ["sse-starlette", "starlette"]
+fastapi = ["a2a-sdk[http-server]", "fastapi>=0.115.2"]
+encryption = ["cryptography>=43.0.0"]
+grpc = ["grpcio>=1.60", "grpcio-tools>=1.60", "grpcio_reflection>=1.7.0"]
+telemetry = ["opentelemetry-api>=1.33.0", "opentelemetry-sdk>=1.33.0"]
+postgresql = ["sqlalchemy[asyncio,postgresql-asyncpg]>=2.0.0"]
+mysql = ["sqlalchemy[asyncio,aiomysql]>=2.0.0"]
+signing = ["PyJWT>=2.0.0"]
+sqlite = ["sqlalchemy[asyncio,aiosqlite]>=2.0.0"]
+db-cli = ["alembic>=1.14.0"]
+
+sql = ["a2a-sdk[postgresql,mysql,sqlite]"]
+
+all = [
+  "a2a-sdk[http-server]",
+  "a2a-sdk[fastapi]",
+  "a2a-sdk[sql]",
+  "a2a-sdk[encryption]",
+  "a2a-sdk[grpc]",
+  "a2a-sdk[telemetry]",
+  "a2a-sdk[signing]",
+  "a2a-sdk[db-cli]",
+]
+
+[project.urls]
+homepage = "https://a2a-protocol.org/"
+repository = "https://github.com/a2aproject/a2a-python"
+changelog = "https://github.com/a2aproject/a2a-python/blob/main/CHANGELOG.md"
+documentation = "https://a2a-protocol.org/latest/sdk/python/"
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/a2a"]
 
+[tool.hatch.build.targets.sdist]
+exclude = ["tests/"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"
 python_functions = "test_*"
-addopts = "--cov=src --cov-config=.coveragerc --cov-report term --cov-report xml:coverage.xml --cov-branch"
+addopts = "-ra --strict-markers --dist loadgroup"
+markers = [
+  "asyncio: mark a test as a coroutine that should be run by pytest-asyncio",
+  "xdist_group: mark a test to run in a specific sequential group for isolation",
+]
+filterwarnings = [
+  # SQLAlchemy warning about duplicate class registration - this is a known limitation
+  # of the dynamic model creation pattern used in models.py for custom table names
+  "ignore:This declarative base already contains a class with the same class name:sqlalchemy.exc.SAWarning",
+  # ResourceWarnings from asyncio event loop/socket cleanup during garbage collection
+  # These appear intermittently between tests due to pytest-asyncio and sse-starlette timing
+  "ignore:unclosed event loop:ResourceWarning",
+  "ignore:unclosed transport:ResourceWarning",
+  "ignore:unclosed <socket.socket:ResourceWarning",
+]
 
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+[tool.pytest-asyncio]
+mode = "strict"
 
-[tool.uv.workspace]
-members = [
-    "examples/langgraph",
-    "examples/helloworld",
-    "examples/google_adk/birthday_planner",
-    "examples/google_adk/calendar_agent",
-]
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
 
 [dependency-groups]
 dev = [
-    "datamodel-code-generator>=0.30.0",
-    "mypy>=1.15.0",
-    "pytest>=8.3.5",
-    "pytest-asyncio>=0.26.0",
-    "pytest-cov>=6.1.1",
-    "pytest-mock>=3.14.0",
-    "ruff>=0.11.6",
+  "fastapi>=0.115.2",
+  "PyJWT>=2.0.0",
+  "pytest>=8.3.5",
+  "pytest-asyncio>=0.26.0",
+  "pytest-cov>=6.1.1",
+  "pytest-mock>=3.14.0",
+  "pytest-xdist>=3.6.1",
+  "respx>=0.20.2",
+  # Test-only oracle. The RFC 8785 conformance tests check the canonicalizer
+  # against an independent implementation, so a mistake shared between the
+  # implementation and its tests still shows up. Not a runtime dependency.
+  "rfc8785>=0.1.4",
+  "ruff>=0.12.8",
+  "uv-dynamic-versioning>=0.8.2",
+  "types-protobuf",
+  "types-requests",
+  "pre-commit",
+  "trio",
+  "uvicorn>=0.35.0",
+  "pytest-timeout>=2.4.0",
+  "a2a-sdk[all]",
+  "ty>=0.0.34",
+]
+
+[tool.uv.workspace]
+# The ITK agent (itk/) is a workspace member so the repo has ONE uv.lock.
+# A separate itk/uv.lock silently went stale whenever a root dependency
+# changed (it embeds a2a-sdk's metadata), which broke every SDK's ITK run
+# that builds this repo as a peer. One lock, kept honest by the same
+# `uv sync --locked` CI the root already runs.
+members = ["itk"]
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[tool.uv.sources]
+a2a-sdk = { workspace = true }
+
+[tool.ty]
+
+[tool.ty.environment]
+python-version = "3.10"
+
+[tool.ty.src]
+include = ["src"]
+exclude = [
+  "**/__pycache__",
+  "**/dist",
+  "**/build",
+  "**/node_modules",
+  "**/venv",
+  "**/.venv",
+  "src/a2a/types",
+  "src/a2a/compat/v0_3/*_pb2*.py",
+  "src/a2a/compat/v0_3/proto_utils.py",
 ]
+
+[tool.coverage.run]
+branch = true
+omit = [
+    "*/tests/*",
+    "*/site-packages/*",
+    "*/__init__.py",
+    "src/a2a/types/a2a_pb2.py",
+    "src/a2a/types/a2a_pb2_grpc.py",
+    "src/a2a/compat/*/*_pb2*.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "import",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING",
+    "@abstractmethod",
+    "pass",
+    "raise ImportError",
+]
+
+#
+# Ruff linter and code formatter for A2A
+#
+[tool.ruff]
+# This file follows the standards in Google Python Style Guide
+# https://google.github.io/styleguide/pyguide.html
+line-length = 80 # Google Style Guide §3.2: 80 columns
+indent-width = 4 # Google Style Guide §3.4: 4 spaces
+target-version = "py310" # Minimum Python version
+
+[tool.ruff.lint]
+preview = true
+explicit-preview-rules = true
+ignore = [
+    "COM812", # Trailing comma missing.
+    "FBT001", # Boolean positional arg in function definition
+    "FBT002", # Boolean default value in function definition
+    "D203",   # 1 blank line required before class docstring (Google: 0)
+    "D213",   # Multi-line docstring summary should start at the second line (Google: first line)
+    "D100",   # Ignore Missing docstring in public module (often desired at top level __init__.py)
+    "D104",   # Ignore Missing docstring in public package (often desired at top level __init__.py)
+    "D107",   # Ignore Missing docstring in __init__ (use class docstring)
+    "TD002",  # Ignore Missing author in TODOs (often not required)
+    "TD003",  # Ignore Missing issue link in TODOs (often not required/available)
+    "T201",   # Ignore print presence
+    "RUF012", # Ignore Mutable class attributes should be annotated with `typing.ClassVar`
+    "E501",   # Ignore line length (handled by Ruff's dynamic line length)
+    "ANN002",
+    "ANN003",
+    "ANN401",
+    "TRY003",
+    "TRY201",
+    "FIX002",
+]
+
+select = [
+    "E",  # pycodestyle errors (PEP 8)
+    "W",  # pycodestyle warnings (PEP 8)
+    "F",  # Pyflakes (logical errors, unused imports/variables)
+    "I",  # isort (import sorting - Google Style §3.1.2)
+    "D",  # pydocstyle (docstring conventions - Google Style §3.8)
+    "N",  # pep8-naming (naming conventions - Google Style §3.16)
+    "UP", # pyupgrade (use modern Python syntax)
+    "ANN",# flake8-annotations (type hint usage/style - Google Style §2.22)
+    "A",  # flake8-builtins (avoid shadowing builtins)
+    "B",  # flake8-bugbear (potential logic errors & style issues - incl. mutable defaults B006, B008)
+    "C4", # flake8-comprehensions (unnecessary list/set/dict comprehensions)
+    "ISC",# flake8-implicit-str-concat (disallow implicit string concatenation across lines)
+    "T20",# flake8-print (discourage `print` - prefer logging)
+    "SIM",# flake8-simplify (simplify code, e.g., `if cond: return True else: return False`)
+    "PTH",# flake8-use-pathlib (use pathlib instead of os.path where possible)
+    "PL", # Pylint rules ported to Ruff (PLC, PLE, PLR, PLW)
+    "PIE",# flake8-pie (misc code improvements, e.g., no-unnecessary-pass)
+    "RUF",# Ruff-specific rules (e.g., RUF001-003 ambiguous unicode, RUF013 implicit optional)
+    "RET",# flake8-return (consistency in return statements)
+    "SLF",# flake8-self (check for private member access via `self`)
+    "TID",# flake8-tidy-imports (relative imports, banned imports - configure if needed)
+    "YTT",# flake8-boolean-trap (checks for boolean positional arguments, truthiness tests - Google Style §3.10)
+    "TD", # flake8-todos (check TODO format - Google Style §3.7)
+    "TCH",# flake8-type-checking (helps manage TYPE_CHECKING blocks and imports)
+    "PYI",# flake8-pyi (best practices for .pyi stub files, some rules are useful for .py too)
+    "S",  # flake8-bandit (security issues)
+    "DTZ",# flake8-datetimez (timezone-aware datetimes)
+    "ERA",# flake8-eradicate (commented-out code)
+    "Q",  # flake8-quotes (quote style consistency)
+    "RSE",# flake8-raise (modern raise statements)
+    "TRY",# tryceratops (exception handling best practices)
+    "PERF",# perflint (performance anti-patterns)
+    "BLE",
+    "T10",
+    "ICN",
+    "G",
+    "FIX",
+    "ASYNC",
+    "INP",
+]
+
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "*/migrations/*",
+    "src/a2a/types/a2a_pb2.py",
+    "src/a2a/types/a2a_pb2.pyi",
+    "src/a2a/types/a2a_pb2_grpc.py",
+    "src/a2a/compat/v0_3/*_pb2.py",
+    "src/a2a/compat/v0_3/*_pb2.pyi",
+    "src/a2a/compat/v0_3/*_pb2_grpc.py",
+]
+
+[tool.ruff.lint.isort]
+case-sensitive = true
+lines-after-imports = 2
+lines-between-types = 1
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+ignore-decorators = ["typing.overload", "abc.abstractmethod"]
+
+[tool.ruff.lint.flake8-annotations]
+mypy-init-return = true
+allow-star-arg-any = false
+
+[tool.ruff.lint.pep8-naming]
+ignore-names = ["test_*", "setUp", "tearDown", "mock_*"]
+classmethod-decorators = ["classmethod", "pydantic.validator", "pydantic.root_validator"]
+staticmethod-decorators = ["staticmethod"]
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all" # Google generally prefers absolute imports (§3.1.2)
+
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "double"
+inline-quotes = "single"
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401", "D", "ANN"]  # Ignore unused imports in __init__.py
+"*_test.py" = [
+    "D",      # All pydocstyle rules
+    "ANN",    # Missing type annotation for function argument
+    "RUF013", # Implicit optional type in test function signatures
+    "S101",   # Use of `assert` detected (expected in tests)
+    "PLR2004",
+    "SLF001",
+]
+"test_*.py" = [
+    "D",
+    "ANN",
+    "RUF013",
+    "S101",
+    "PLR2004",
+    "SLF001",
+]
+"types.py" = ["D", "E501"]  # Ignore docstring and annotation issues in types.py
+"proto_utils.py" = ["D102", "PLR0911"]
+"helpers.py" = ["ANN001", "ANN201", "ANN202"]
+"scripts/*.py" = ["INP001"]
+
+[tool.ruff.format]
+exclude = [
+    "src/a2a/types/a2a_pb2.py",
+    "src/a2a/types/a2a_pb2.pyi",
+    "src/a2a/types/a2a_pb2_grpc.py",
+    "src/a2a/compat/v0_3/*_pb2.py",
+    "src/a2a/compat/v0_3/*_pb2.pyi",
+    "src/a2a/compat/v0_3/*_pb2_grpc.py",
+]
+docstring-code-format = true
+docstring-code-line-length = "dynamic"
+quote-style = "single"
+indent-style = "space"
+
+
+[tool.alembic]
+
+# path to migration scripts.
+script_location = "src/a2a/migrations"
+
+# additional paths to be prepended to sys.path. defaults to the current working directory.
+prepend_sys_path = [
+    "src"
+]
+
+[project.scripts]
+a2a-db = "a2a.a2a_db_cli:run_migrations"
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 000000000..4e525ffc6
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,9 @@
+{
+  "release-type": "python",
+  "include-component-in-tag": false,
+  "packages": {
+    ".": {
+      "versioning": "always-bump-patch"
+    }
+  }
+}
diff --git a/samples/README.md b/samples/README.md
new file mode 100644
index 000000000..d8018bbcc
--- /dev/null
+++ b/samples/README.md
@@ -0,0 +1,86 @@
+# A2A Python SDK — Samples
+
+This directory contains runnable examples demonstrating how to build and interact with an A2A-compliant agent using the Python SDK.
+
+## Contents
+
+| File | Role | Description |
+|---|---|---|
+| `hello_world_agent.py` | **Server** | A2A agent server |
+| `cli.py` | **Client** | Interactive terminal client |
+| `agent_card_signing.py` | **Server + Client** | Signing and verifying an Agent Card |
+
+The samples are designed to work together out of the box: the agent listens on `http://127.0.0.1:41241`, which is the default URL used by the client.
+---
+
+## `hello_world_agent.py` — Agent Server
+
+Implements an A2A agent that responds to simple greeting messages (e.g., "hello", "how are you", "bye") with text replies, simulating a 1-second processing delay.
+
+Demonstrates:
+- Subclassing `AgentExecutor` and implementing `execute()` / `cancel()`
+- Publishing streaming status updates and artifacts via `TaskUpdater`
+- Exposing all three transports in both protocol versions (v1.0 and v0.3 compat) simultaneously:
+  - **JSON-RPC** (v1.0 and v0.3) at `http://127.0.0.1:41241/a2a/jsonrpc`
+  - **HTTP+JSON (REST)** (v1.0 and v0.3) at `http://127.0.0.1:41241/a2a/rest`
+  - **gRPC v1.0** on port `50051`
+  - **gRPC v0.3 (compat)** on port `50052`
+- Serving the agent card at `http://127.0.0.1:41241/.well-known/agent-card.json`
+
+**Run:**
+
+```bash
+uv run python samples/hello_world_agent.py
+```
+
+---
+
+## `cli.py` — Client
+
+An interactive terminal client with full visibility into the streaming event flow. Each `TaskStatusUpdate` and `TaskArtifactUpdate` event is printed as it arrives.
+
+Features:
+- Transport selection via `--transport` flag (`JSONRPC`, `HTTP+JSON`, `GRPC`)
+- Session management (`context_id` persisted across messages, `task_id` per task)
+- Graceful error handling for HTTP and gRPC failures
+
+**Run:**
+
+```bash
+# Connect to the local hello_world_agent (default):
+uv run python samples/cli.py
+
+# Connect to a different URL, using gRPC:
+uv run python samples/cli.py --url http://192.168.1.10:41241 --transport GRPC
+```
+
+Then type a message like `hello` and press Enter.
+
+Type `/quit` or `/exit` to stop, or press `Ctrl+C`.
+
+---
+
+## `agent_card_signing.py` — Agent Card Signing
+
+An Agent Card is fetched before any trust has been established with the agent, so everything in it — transport URLs, security schemes, skills — is attacker-controlled until it is verified. This sample signs a card on the server and verifies it on the client.
+
+Demonstrates:
+- Signing the Agent Card with an ES256 key via `create_agent_card_signer`, wired into the card endpoint through `create_agent_card_routes(card_modifier=...)`
+- Publishing the matching public key as a JWKS document at `/.well-known/jwks.json`, referenced by the signature's `jku` header
+- Verifying the card with `create_signature_verifier`, passed to `A2ACardResolver.get_agent_card(signature_verifier=...)` (the same argument is accepted by `ClientFactory.create_from_url`)
+- Pinning trust: the verifier accepts keys only from an allowlist of JWKS URLs and only signatures using an allowlisted algorithm
+
+The default `demo` mode starts the server, verifies its card, and then shows the three failures a verifier exists to catch: a card whose transport URL was rewritten in transit, a card with its signature stripped, and a genuine card whose `jku` the client does not trust.
+
+**Run:**
+
+```bash
+# Server and client together (default):
+uv run python samples/agent_card_signing.py
+
+# Or run the two halves separately:
+uv run python samples/agent_card_signing.py serve
+uv run python samples/agent_card_signing.py verify --url http://127.0.0.1:41242
+```
+
+Requires the `signing`, `encryption` and `fastapi` extras (`pip install 'a2a-sdk[signing,encryption,fastapi]'`); they are already present when working from a `uv sync` of this repo.
diff --git a/samples/__init__.py b/samples/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/agent_card_signing.py b/samples/agent_card_signing.py
new file mode 100644
index 000000000..499a80b4c
--- /dev/null
+++ b/samples/agent_card_signing.py
@@ -0,0 +1,520 @@
+"""Agent Card signing and verification sample.
+
+An A2A Agent Card is fetched over the network before any trust has been
+established with the agent, so everything inside it -- the transport URLs, the
+security schemes, the skills -- is attacker-controlled until it has been
+verified. Card signing closes that gap: the agent signs the canonical form of
+its own card with a private key (JWS, RFC 7515) and the client verifies that
+signature against a public key it trusts before using the card.
+
+This sample runs both halves:
+
+**Server** (`serve`)
+  - Signs the public Agent Card with an ES256 key using
+    `a2a.utils.signing.create_agent_card_signer`.
+  - Serves the signed card at `/.well-known/agent-card.json`.
+  - Publishes the matching public key as a JWKS document at
+    `/.well-known/jwks.json`, which the signature's `jku` header points to.
+
+**Client** (`verify`)
+  - Fetches the card with `A2ACardResolver` and verifies it with
+    `a2a.utils.signing.create_signature_verifier`.
+  - Resolves the verification key by `kid` from JWKS documents it fetched from
+    an explicit allowlist of URLs -- following the card's own `jku` blindly
+    would let an attacker serve both a forged card and the key that "verifies"
+    it.
+
+Run:
+
+```bash
+# End-to-end demo: starts the server, verifies a good card, then shows the
+# failures a verifier is there to catch.
+uv run python samples/agent_card_signing.py
+
+# Server only.
+uv run python samples/agent_card_signing.py serve
+
+# Verify a card served by another process.
+uv run python samples/agent_card_signing.py verify --url http://127.0.0.1:41242
+```
+
+Requires the `signing`, `encryption` and `fastapi` extras:
+`pip install 'a2a-sdk[signing,encryption,fastapi]'`.
+"""
+
+import argparse
+import asyncio
+import contextlib
+import copy
+import json
+import logging
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+import httpx
+import uvicorn
+
+from cryptography.hazmat.primitives.asymmetric import ec
+from fastapi import FastAPI
+from jwt.algorithms import ECAlgorithm
+from jwt.api_jwk import PyJWK, PyJWKSet
+from jwt.exceptions import PyJWKError
+from jwt.utils import base64url_decode
+
+from a2a.client import A2ACardResolver
+from a2a.client.card_resolver import parse_agent_card
+from a2a.server.routes import (
+    add_a2a_routes_to_fastapi,
+    create_agent_card_routes,
+)
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+)
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from a2a.utils.signing import (
+    InvalidSignaturesError,
+    NoSignatureError,
+    ProtectedHeader,
+    create_agent_card_signer,
+    create_signature_verifier,
+)
+
+
+logger = logging.getLogger(__name__)
+
+JWKS_WELL_KNOWN_PATH = '/.well-known/jwks.json'
+SIGNING_KEY_ID = 'sample-card-key-1'
+SIGNING_ALGORITHM = 'ES256'
+DEFAULT_HOST = '127.0.0.1'
+DEFAULT_PORT = 41242
+
+# The verifier accepts only these algorithms. Pinning them prevents algorithm
+# confusion attacks, where a forged card names a weaker algorithm that the
+# verifier would otherwise happily accept.
+ALLOWED_ALGORITHMS = ['ES256']
+
+
+# --------------------------------------------------------------------------- #
+# Server: sign the card, publish the public key
+# --------------------------------------------------------------------------- #
+
+
+def generate_signing_key(
+    kid: str = SIGNING_KEY_ID,
+) -> tuple[ec.EllipticCurvePrivateKey, dict[str, Any]]:
+    """Generates an ES256 key pair for card signing.
+
+    A real deployment loads a long-lived private key from a key management
+    service or secret store instead. The public half is returned as a JWKS document, ready
+    to be served at a stable URL.
+
+    Args:
+        kid: The key ID advertised in the JWS header and in the JWKS.
+
+    Returns:
+        A tuple of (private key, JWKS document).
+    """
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    public_jwk: dict[str, Any] = ECAlgorithm.to_jwk(
+        private_key.public_key(), as_dict=True
+    )
+    jwks = {
+        'keys': [
+            {**public_jwk, 'kid': kid, 'alg': SIGNING_ALGORITHM, 'use': 'sig'}
+        ]
+    }
+    return private_key, jwks
+
+
+def build_agent_card(base_url: str) -> AgentCard:
+    """Builds the Agent Card that will be signed and served."""
+    return AgentCard(
+        name='Signed Card Agent',
+        description='An agent that serves a signed Agent Card.',
+        provider=AgentProvider(
+            organization='A2A Samples', url='https://example.com'
+        ),
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True, push_notifications=False
+        ),
+        default_input_modes=['text'],
+        default_output_modes=['text'],
+        skills=[
+            AgentSkill(
+                id='signed_card',
+                name='Signed Card',
+                description='Say hi.',
+                tags=['sample', 'signing'],
+                examples=['hi'],
+            )
+        ],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+                url=f'{base_url}/a2a/jsonrpc',
+            ),
+        ],
+    )
+
+
+def sign_agent_card(
+    agent_card: AgentCard,
+    private_key: ec.EllipticCurvePrivateKey,
+    jku: str,
+    kid: str = SIGNING_KEY_ID,
+) -> AgentCard:
+    """Signs a copy of an Agent Card and returns the signed copy.
+
+    The signature covers the JCS-canonicalized (RFC 8785) card with its
+    `signatures` field removed, so a client can recompute exactly the same bytes
+    from the card it received.
+
+    Args:
+        agent_card: The card to sign. It is copied rather than modified: the
+            signer appends to `card.signatures`, so signing the same card object
+            twice would leave it carrying two signatures.
+        private_key: The private key to sign with.
+        jku: URL of the JWKS document holding the matching public key. Clients
+            use it to select the verification key.
+        kid: ID of the signing key within that JWKS.
+
+    Returns:
+        A signed copy of the card.
+    """
+    protected_header: ProtectedHeader = {
+        'alg': SIGNING_ALGORITHM,
+        'kid': kid,
+        'jku': jku,
+        # RFC 7515 §4.1.9: "JOSE" marks a JWS using the JSON serialization.
+        'typ': 'JOSE',
+    }
+    signer = create_agent_card_signer(
+        signing_key=private_key,
+        protected_header=protected_header,
+    )
+    return signer(copy.deepcopy(agent_card))
+
+
+def create_app(base_url: str, jwks_path: str = JWKS_WELL_KNOWN_PATH) -> FastAPI:
+    """Creates a FastAPI app serving a signed Agent Card and its JWKS.
+
+    Args:
+        base_url: Public base URL of this server. It ends up in the card's
+            interface URLs and in the `jku` of the signature, so it has to be
+            the URL clients actually reach.
+        jwks_path: Path the public keys are served from.
+
+    Returns:
+        The FastAPI application.
+    """
+    private_key, jwks = generate_signing_key()
+    agent_card = build_agent_card(base_url)
+    jku = f'{base_url}{jwks_path}'
+
+    # The card is static here, so it is signed once at startup. `card_modifier`
+    # runs on every request, which is the hook to use when the served card is
+    # built per request (per-caller skills, dynamic URLs) and therefore has to
+    # be re-signed each time.
+    signed_card = sign_agent_card(agent_card, private_key, jku=jku)
+
+    async def card_modifier(card: AgentCard) -> AgentCard:
+        return signed_card
+
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(
+        app,
+        agent_card_routes=create_agent_card_routes(
+            agent_card=agent_card,
+            card_modifier=card_modifier,
+        ),
+    )
+
+    @app.get(jwks_path)
+    async def get_jwks() -> dict[str, Any]:
+        """Publishes the public keys clients use to verify the card."""
+        return jwks
+
+    return app
+
+
+# --------------------------------------------------------------------------- #
+# Client: verify the card before trusting it
+# --------------------------------------------------------------------------- #
+
+
+class JwksKeyProvider:
+    """Resolves an Agent Card signature's verification key from trusted JWKS.
+
+    A signature's `jku` header says where its key lives -- but that header is
+    part of the card, which is exactly what is not yet trusted. So this provider
+    holds keys fetched from an allowlist of JWKS URLs and serves a signature
+    only if its `jku` is one of them. Without that check an attacker could serve
+    a forged card alongside a JWKS holding their own key, and the signature
+    would verify perfectly.
+
+    Lookups are pure in-memory: the verifier is a synchronous callable, often
+    invoked from async code, so it must not do blocking network I/O. Fetch and
+    refresh the key sets out of band with `fetch`.
+    """
+
+    def __init__(self, jwks_by_url: Mapping[str, PyJWKSet]) -> None:
+        """Initializes the key provider.
+
+        Args:
+            jwks_by_url: Already-fetched key sets, keyed by their JWKS URL.
+                A signature naming any other `jku` is rejected.
+        """
+        self._jwks_by_url = dict(jwks_by_url)
+
+    @classmethod
+    async def fetch(
+        cls, trusted_jku_urls: set[str], http_client: httpx.AsyncClient
+    ) -> 'JwksKeyProvider':
+        """Fetches every trusted JWKS and builds a provider from them.
+
+        Args:
+            trusted_jku_urls: JWKS URLs this client is willing to accept keys
+                from, pinned by configuration rather than read off the card.
+            http_client: Client used to fetch the key sets.
+
+        Returns:
+            A provider serving the fetched keys.
+        """
+        jwks_by_url = {}
+        for url in trusted_jku_urls:
+            response = await http_client.get(url)
+            response.raise_for_status()
+            jwks_by_url[url] = PyJWKSet.from_dict(response.json())
+        return cls(jwks_by_url)
+
+    def __call__(self, kid: str | None, jku: str | None) -> PyJWK:
+        """Returns the verification key for one signature.
+
+        Failures are raised as `PyJWKError` (a `PyJWTError`) so the verifier
+        treats this one signature as unverifiable and moves on to the next,
+        rather than aborting on a card that also carries a good signature.
+
+        Args:
+            kid: Key ID from the signature's protected header.
+            jku: JWKS URL from the signature's protected header.
+
+        Returns:
+            The public key to verify the signature with.
+
+        Raises:
+            PyJWKError: If the `jku` is not trusted, the `kid` is missing, or no
+                key with that `kid` is published at that `jku`.
+        """
+        if not jku or jku not in self._jwks_by_url:
+            raise PyJWKError(f'Signature names an untrusted jku: {jku}')
+        if not kid:
+            raise PyJWKError('Signature is missing a kid')
+
+        try:
+            return self._jwks_by_url[jku][kid]
+        except KeyError as e:
+            raise PyJWKError(f'No key with kid {kid!r} at {jku}') from e
+
+
+async def create_card_verifier(
+    trusted_jku_urls: set[str], http_client: httpx.AsyncClient
+) -> Callable[[AgentCard], None]:
+    """Builds a verifier that accepts cards signed by the trusted keys.
+
+    Args:
+        trusted_jku_urls: JWKS URLs to accept signing keys from.
+        http_client: Client used to fetch those key sets.
+
+    Returns:
+        A callable that raises `SignatureVerificationError` for a card it cannot
+        verify, and returns `None` for one it can.
+    """
+    key_provider = await JwksKeyProvider.fetch(trusted_jku_urls, http_client)
+    return create_signature_verifier(
+        key_provider=key_provider,
+        algorithms=ALLOWED_ALGORITHMS,
+    )
+
+
+async def verify_remote_card(base_url: str) -> AgentCard:
+    """Fetches an Agent Card and verifies its signature before returning it.
+
+    Args:
+        base_url: Base URL of the agent serving the card.
+
+    Returns:
+        The verified Agent Card.
+
+    Raises:
+        SignatureVerificationError: If the card carries no signature, or none of
+            its signatures can be verified.
+    """
+    async with httpx.AsyncClient() as http_client:
+        verifier = await create_card_verifier(
+            trusted_jku_urls={f'{base_url}{JWKS_WELL_KNOWN_PATH}'},
+            http_client=http_client,
+        )
+        resolver = A2ACardResolver(http_client, base_url)
+        # `get_agent_card` propagates the verifier's error, so a card it returns
+        # has always been verified.
+        return await resolver.get_agent_card(signature_verifier=verifier)
+
+
+# --------------------------------------------------------------------------- #
+# Demo
+# --------------------------------------------------------------------------- #
+
+
+async def _fetch_card_json(
+    base_url: str, http_client: httpx.AsyncClient
+) -> dict[str, Any]:
+    """Fetches the raw Agent Card JSON, bypassing verification."""
+    response = await http_client.get(f'{base_url}{AGENT_CARD_WELL_KNOWN_PATH}')
+    response.raise_for_status()
+    card_json: dict[str, Any] = response.json()
+    return card_json
+
+
+async def run_demo(base_url: str) -> None:
+    """Verifies a good card, then two cards a verifier should reject."""
+    async with httpx.AsyncClient() as http_client:
+        verifier = await create_card_verifier(
+            trusted_jku_urls={f'{base_url}{JWKS_WELL_KNOWN_PATH}'},
+            http_client=http_client,
+        )
+
+        print('\n1. The card served by the agent')
+        card = await A2ACardResolver(http_client, base_url).get_agent_card(
+            signature_verifier=verifier
+        )
+        # The protected header is base64url-encoded JWS header JSON.
+        protected_header = json.loads(
+            base64url_decode(card.signatures[0].protected.encode('utf-8'))
+        )
+        print(f'   verified card for agent: {card.name}')
+        print(f'   protected header: {protected_header}')
+
+        print('\n2. A card whose transport URL was rewritten in transit')
+        tampered_json = await _fetch_card_json(base_url, http_client)
+        tampered_json['supportedInterfaces'][0]['url'] = (
+            'http://attacker.example/a2a/jsonrpc'
+        )
+        try:
+            verifier(parse_agent_card(tampered_json))
+        except InvalidSignaturesError as e:
+            print(f'   rejected as expected: {e}')
+        else:
+            print('   ERROR: tampered card was accepted')
+
+        print('\n3. A card with its signature stripped off')
+        unsigned_json = await _fetch_card_json(base_url, http_client)
+        unsigned_json.pop('signatures', None)
+        try:
+            verifier(parse_agent_card(unsigned_json))
+        except NoSignatureError as e:
+            print(f'   rejected as expected: {e}')
+        else:
+            print('   ERROR: unsigned card was accepted')
+
+        print('\n4. The genuine card, checked by a client that pins other keys')
+        # Same keys, published at a URL this client does not trust. The
+        # signature itself is fine; it is the key source that is not pinned, so
+        # the card is rejected rather than verified against whatever the card
+        # points at.
+        keys_response = await http_client.get(
+            f'{base_url}{JWKS_WELL_KNOWN_PATH}'
+        )
+        pinned_elsewhere = create_signature_verifier(
+            key_provider=JwksKeyProvider(
+                {
+                    'https://keys.example.com/jwks.json': PyJWKSet.from_dict(
+                        keys_response.json()
+                    )
+                }
+            ),
+            algorithms=ALLOWED_ALGORITHMS,
+        )
+        try:
+            pinned_elsewhere(card)
+        except InvalidSignaturesError as e:
+            print(f'   rejected as expected: {e}')
+        else:
+            print('   ERROR: card with an untrusted jku was accepted')
+
+
+async def serve(host: str, port: int) -> None:
+    """Runs the signed-card agent server."""
+    base_url = f'http://{host}:{port}'
+    config = uvicorn.Config(create_app(base_url), host=host, port=port)
+    server = uvicorn.Server(config)
+    logger.info('Signed Agent Card: %s%s', base_url, AGENT_CARD_WELL_KNOWN_PATH)
+    logger.info('JWKS: %s%s', base_url, JWKS_WELL_KNOWN_PATH)
+    await server.serve()
+
+
+async def serve_and_demo(host: str, port: int) -> None:
+    """Starts the server, runs the client demo against it, then shuts down."""
+    base_url = f'http://{host}:{port}'
+    config = uvicorn.Config(
+        create_app(base_url), host=host, port=port, log_level='warning'
+    )
+    server = uvicorn.Server(config)
+    server_task = asyncio.create_task(server.serve())
+    try:
+        # uvicorn signals readiness with a flag rather than an event.
+        while not server.started:  # noqa: ASYNC110
+            await asyncio.sleep(0.05)
+        print(f'Serving a signed Agent Card at {base_url}')
+        await run_demo(base_url)
+    finally:
+        server.should_exit = True
+        await server_task
+
+
+def main() -> None:
+    """Parses arguments and runs the requested mode."""
+    logging.basicConfig(level=logging.INFO)
+    server_args = argparse.ArgumentParser(add_help=False)
+    server_args.add_argument('--host', default=DEFAULT_HOST)
+    server_args.add_argument('--port', type=int, default=DEFAULT_PORT)
+
+    parser = argparse.ArgumentParser(
+        description='A2A Agent Card signing sample'
+    )
+    parser.set_defaults(mode='demo', host=DEFAULT_HOST, port=DEFAULT_PORT)
+    subparsers = parser.add_subparsers(dest='mode')
+    subparsers.add_parser(
+        'demo',
+        parents=[server_args],
+        help='Run the server and the client (default)',
+    )
+    subparsers.add_parser(
+        'serve', parents=[server_args], help='Run the server only'
+    )
+    verify_parser = subparsers.add_parser(
+        'verify', help='Verify a card served elsewhere'
+    )
+    verify_parser.add_argument(
+        '--url', default=f'http://{DEFAULT_HOST}:{DEFAULT_PORT}'
+    )
+
+    args = parser.parse_args()
+    if args.mode == 'serve':
+        asyncio.run(serve(args.host, args.port))
+    elif args.mode == 'verify':
+        card = asyncio.run(verify_remote_card(args.url))
+        print(f'Verified card for agent: {card.name}')
+    else:
+        asyncio.run(serve_and_demo(args.host, args.port))
+
+
+if __name__ == '__main__':
+    with contextlib.suppress(KeyboardInterrupt):
+        main()
diff --git a/samples/cli.py b/samples/cli.py
new file mode 100644
index 000000000..beff26aa9
--- /dev/null
+++ b/samples/cli.py
@@ -0,0 +1,135 @@
+import argparse
+import asyncio
+import os
+import signal
+import uuid
+
+from typing import Any
+
+import grpc
+import httpx
+
+from a2a.client import A2ACardResolver, ClientConfig, create_client
+from a2a.helpers import get_artifact_text, get_message_text
+from a2a.helpers.agent_card import display_agent_card
+from a2a.types import Message, Part, Role, SendMessageRequest, TaskState
+
+
+async def _handle_stream(
+    stream: Any, current_task_id: str | None
+) -> str | None:
+    async for event in stream:
+        if event.HasField('message'):
+            print('Message:', get_message_text(event.message, delimiter=' '))
+            return None
+
+        if not current_task_id:
+            if event.HasField('task'):
+                current_task_id = event.task.id
+                print('--- Task Started ---')
+                print(f'Task [state={TaskState.Name(event.task.status.state)}]')
+            else:
+                raise ValueError(f'Unexpected first event: {event}')
+
+        if event.HasField('status_update'):
+            state_name = TaskState.Name(event.status_update.status.state)
+            message_text = (
+                ': '
+                + get_message_text(
+                    event.status_update.status.message, delimiter=' '
+                )
+                if event.status_update.status.HasField('message')
+                else ''
+            )
+            print(f'TaskStatusUpdate [state={state_name}]{message_text}')
+            if state_name in (
+                'TASK_STATE_COMPLETED',
+                'TASK_STATE_FAILED',
+                'TASK_STATE_CANCELED',
+                'TASK_STATE_REJECTED',
+            ):
+                current_task_id = None
+                print('--- Task Finished ---')
+        elif event.HasField('artifact_update'):
+            print(
+                f'TaskArtifactUpdate [name={event.artifact_update.artifact.name}]:',
+                get_artifact_text(
+                    event.artifact_update.artifact, delimiter=' '
+                ),
+            )
+    return current_task_id
+
+
+async def main() -> None:
+    """Run the A2A terminal client."""
+    parser = argparse.ArgumentParser(description='A2A Terminal Client')
+    parser.add_argument(
+        '--url', default='http://127.0.0.1:41241', help='Agent base URL'
+    )
+    parser.add_argument(
+        '--transport',
+        default=None,
+        help='Preferred transport (JSONRPC, HTTP+JSON, GRPC)',
+    )
+    args = parser.parse_args()
+
+    config = ClientConfig(
+        grpc_channel_factory=grpc.aio.insecure_channel,
+    )
+    if args.transport:
+        config.supported_protocol_bindings = [args.transport]
+
+    print(
+        f'Connecting to {args.url} (preferred transport: {args.transport or "Any"})'
+    )
+
+    async with httpx.AsyncClient() as httpx_client:
+        resolver = A2ACardResolver(httpx_client, args.url)
+        card = await resolver.get_agent_card()
+        print('\n✓ Agent Card Found:')
+        display_agent_card(card)
+
+    client = await create_client(card, client_config=config)
+
+    actual_transport = getattr(client, '_transport', client)
+    print(f'  Picked Transport: {actual_transport.__class__.__name__}')
+
+    print('\nConnected! Send a message or type /quit to exit.')
+
+    current_task_id = None
+    current_context_id = str(uuid.uuid4())
+
+    while True:
+        try:
+            loop = asyncio.get_running_loop()
+            user_input = await loop.run_in_executor(None, input, 'You: ')
+        except KeyboardInterrupt:
+            break
+
+        if user_input.lower() in ('/quit', '/exit'):
+            break
+        if not user_input.strip():
+            continue
+
+        message = Message(
+            role=Role.ROLE_USER,
+            message_id=str(uuid.uuid4()),
+            parts=[Part(text=user_input)],
+            task_id=current_task_id,
+            context_id=current_context_id,
+        )
+
+        request = SendMessageRequest(message=message)
+
+        try:
+            stream = client.send_message(request)
+            current_task_id = await _handle_stream(stream, current_task_id)
+        except (httpx.RequestError, grpc.RpcError) as e:
+            print(f'Error communicating with agent: {e}')
+
+    await client.close()
+
+
+if __name__ == '__main__':
+    signal.signal(signal.SIGINT, lambda sig, frame: os._exit(0))
+    asyncio.run(main())
diff --git a/samples/clustermode/README.md b/samples/clustermode/README.md
new file mode 100644
index 000000000..1ec16a567
--- /dev/null
+++ b/samples/clustermode/README.md
@@ -0,0 +1,74 @@
+# Cluster-mode sample (multi-replica A2A)
+
+Runs several A2A server replicas that share one durable task store and one event
+stream, so any replica can serve any request for any task. This demonstrates the
+multi-server support in `a2a.server.cluster`: send, resubscribe, and cancel all
+work regardless of which replica a request lands on — no sticky routing needed.
+
+## What it shows
+
+- **Shared, versioned task store** (`VersionedDatabaseTaskStore`) — concurrent
+  writes across replicas are serialized by optimistic concurrency (CAS); no lost
+  updates.
+- **Shared event stream** (`DatabaseTaskEventStream`) — a subscription on one replica
+  streams events produced by an agent running on another.
+- **Cancel via CAS** — a cancel on replica C stops an agent running on replica A
+  (A's next save fails the compare-and-swap and aborts).
+
+## Requirements
+
+Nothing extra by default: it uses a file-backed SQLite database
+(`/tmp/a2a_cluster_demo.db`) shared by all replica processes.
+
+For a realistic setup, point every replica at a shared Postgres/MySQL:
+
+```bash
+export A2A_CLUSTER_DSN='postgresql+asyncpg://user:pass@localhost/a2a'
+```
+
+## Run
+
+Start a 3-replica cluster (ports 41241, 41242, 41243):
+
+```bash
+python -m samples.clustermode.run_cluster --replicas 3 --base-port 41241
+```
+
+In another terminal, exercise it (one task, spread across replicas):
+
+```bash
+python -m samples.clustermode.exercise --host 127.0.0.1 --ports 41241,41242,41243
+```
+
+Expected output ends with:
+
+```
+OK: one task was started, observed, and cancelled across three different replicas.
+```
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `cluster_common.py` | Shared store/stream wiring, agent card, and the demo agent |
+| `server.py` | One replica (a FastAPI app on one port) |
+| `run_cluster.py` | Launches N replicas as subprocesses |
+| `exercise.py` | Client that sends/gets/cancels one task across replicas |
+
+## How it maps to the API
+
+Every replica builds its handler the same way — the only multi-server-specific
+part is passing a shared `event_stream` and a shared `VersionedTaskStore`:
+
+```python
+handler = DefaultRequestHandler(
+    agent_executor=SlowEchoAgent(...),
+    task_store=VersionedDatabaseTaskStore(engine=..., create_table=False),
+    agent_card=agent_card,
+    event_stream=DatabaseTaskEventStream(engine=..., create_table=False),
+)
+```
+
+Omit `event_stream` (and use a plain `InMemoryTaskStore`) and you get the ordinary
+single-process behaviour — the multi-server path is fully opt-in.
+```
diff --git a/samples/clustermode/__init__.py b/samples/clustermode/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/samples/clustermode/cluster_common.py b/samples/clustermode/cluster_common.py
new file mode 100644
index 000000000..6d13093bc
--- /dev/null
+++ b/samples/clustermode/cluster_common.py
@@ -0,0 +1,171 @@
+"""Shared wiring for the multi-replica (cluster mode) sample.
+
+Every replica in this sample builds its handler from the SAME durable task store
+and the SAME event stream (pointed at one shared database). That is what lets any
+replica serve any request for any task - send, resubscribe, and cancel all work
+regardless of which replica the load balancer picks.
+
+By default this uses a file-backed SQLite database so the sample runs with no
+external services. Set A2A_CLUSTER_DSN to a Postgres/MySQL async DSN for a more
+realistic setup, e.g.:
+
+    export A2A_CLUSTER_DSN='postgresql+asyncpg://user:pass@localhost/a2a'
+"""
+
+import asyncio
+import logging
+import os
+import tempfile
+
+from pathlib import Path
+
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.cluster import VersionedDatabaseTaskStore
+from a2a.server.cluster.database_event_stream import DatabaseTaskEventStream
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.models import Base
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Part,
+    TaskState,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+def default_sqlite_path() -> str:
+    """Path to the shared SQLite file used when no DSN is configured."""
+    return os.environ.get(
+        'A2A_CLUSTER_SQLITE',
+        str(Path(tempfile.gettempdir()) / 'a2a_cluster_demo.db'),
+    )
+
+
+def default_dsn() -> str:
+    """The shared-database DSN. SQLite file by default; override via env."""
+    dsn = os.environ.get('A2A_CLUSTER_DSN')
+    if dsn:
+        return dsn
+    # A file (not :memory:) so separate replica processes share one database.
+    return f'sqlite+aiosqlite:///{default_sqlite_path()}'
+
+
+async def init_schema(dsn: str) -> None:
+    """Creates the shared tables (task + task_events) once, up front."""
+    engine = create_async_engine(dsn)
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+    finally:
+        await engine.dispose()
+
+
+def build_cluster_backends(
+    dsn: str,
+) -> tuple[VersionedDatabaseTaskStore, DatabaseTaskEventStream]:
+    """Builds a versioned store + event stream over the shared database.
+
+    Each replica calls this with the same DSN. `create_table=False` because
+    `init_schema` owns table creation.
+    """
+    store_engine = create_async_engine(dsn)
+    stream_engine = create_async_engine(dsn)
+    store = VersionedDatabaseTaskStore(engine=store_engine, create_table=False)
+    stream = DatabaseTaskEventStream(
+        engine=stream_engine, create_table=False, poll_interval_s=0.2
+    )
+    return store, stream
+
+
+def build_agent_card(base_url: str) -> AgentCard:
+    """The agent card advertised by every replica (same logical agent)."""
+    return AgentCard(
+        name='Cluster Demo Agent',
+        description='A slow agent used to demonstrate multi-replica A2A.',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True, push_notifications=False
+        ),
+        default_input_modes=['text'],
+        default_output_modes=['text', 'task-status'],
+        skills=[
+            AgentSkill(
+                id='cluster_demo',
+                name='Cluster Demo',
+                description='Echoes slowly so you can observe it across replicas.',
+                tags=['sample', 'cluster'],
+                examples=['hello'],
+                input_modes=['text'],
+                output_modes=['text', 'task-status'],
+            )
+        ],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+                url=f'{base_url}/a2a/jsonrpc',
+            ),
+        ],
+    )
+
+
+class SlowEchoAgent(AgentExecutor):
+    """Goes WORKING, emits ticks slowly, then completes.
+
+    The deliberate slowness makes the multi-replica behaviour observable: you
+    can subscribe or cancel from a different replica while a task is mid-flight.
+    Resumability across replicas relies on this agent reading state only from
+    the task (it does not keep anything in process memory between turns).
+    """
+
+    def __init__(self, replica_id: str, ticks: int = 10) -> None:
+        self._replica_id = replica_id
+        self._ticks = ticks
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Runs the slow echo: WORKING, ticks, artifact, complete."""
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        await updater.start_work(
+            message=updater.new_agent_message(
+                [Part(text=f'[{self._replica_id}] starting')]
+            )
+        )
+        for i in range(self._ticks):
+            await asyncio.sleep(1.0)
+            await updater.update_status(
+                TaskState.TASK_STATE_WORKING,
+                message=updater.new_agent_message(
+                    [Part(text=f'[{self._replica_id}] tick {i + 1}')]
+                ),
+            )
+        await updater.add_artifact(
+            [Part(text=f'[{self._replica_id}] done')],
+            name='response',
+            last_chunk=True,
+        )
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """No-op: the stop happens via the store CAS when CANCELED is recorded."""
+        return
diff --git a/samples/clustermode/exercise.py b/samples/clustermode/exercise.py
new file mode 100644
index 000000000..210a25414
--- /dev/null
+++ b/samples/clustermode/exercise.py
@@ -0,0 +1,219 @@
+"""Exercises a running replica cluster across different replicas.
+
+Deliberately spreads one task's requests across replicas to show that, with a
+shared store + event stream, a task started on replica 0 can be observed from
+replica 1 and cancelled from replica 2 - consistently, because no per-task
+state is pinned to a single replica. Uses raw JSON-RPC over httpx with protojson
+bodies, so it depends only on the SDK's proto types.
+
+Usage (after run_cluster.py is up):
+    python -m samples.clustermode.exercise --host 127.0.0.1 --ports 41241,41242
+"""
+
+import argparse
+import asyncio
+import contextlib
+import json
+import uuid
+
+from typing import Any
+
+import httpx
+
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.message import Message as ProtoMessage
+
+from a2a.types import (
+    CancelTaskRequest,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    StreamResponse,
+    Task,
+    TaskState,
+)
+
+
+MIN_REPLICAS = 2
+_WORKING = TaskState.TASK_STATE_WORKING
+_CANCELED = TaskState.TASK_STATE_CANCELED
+
+
+def _endpoint(host: str, port: int) -> str:
+    return f'http://{host}:{port}/a2a/jsonrpc'
+
+
+async def _rpc(
+    client: httpx.AsyncClient,
+    url: str,
+    method: str,
+    params_msg: ProtoMessage,
+) -> dict[str, Any]:
+    """Sends one JSON-RPC call with a protojson params body; returns result."""
+    body = {
+        'jsonrpc': '2.0',
+        'id': str(uuid.uuid4()),
+        'method': method,
+        'params': MessageToDict(params_msg),
+    }
+    # This sample speaks the v1.0 protocol; the header selects the v1 handler.
+    resp = await client.post(
+        url, json=body, headers={'A2A-Version': '1.0'}, timeout=30.0
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    if 'error' in data:
+        raise RuntimeError(f'{method} error: {data["error"]}')
+    return data['result']
+
+
+async def _get_task(client: httpx.AsyncClient, url: str, task_id: str) -> Task:
+    """Fetches a task via GetTask from the given replica."""
+    result = await _rpc(client, url, 'GetTask', GetTaskRequest(id=task_id))
+    task = Task()
+    ParseDict(result, task)
+    return task
+
+
+async def _start_streaming(
+    client: httpx.AsyncClient, url: str, send: SendMessageRequest
+) -> tuple[str, asyncio.Task[None]]:
+    """Starts a streaming send; returns (task_id, drainer task).
+
+    The drainer keeps the SSE stream open (so the agent keeps running) until it
+    is cancelled. The task id is taken from the first streamed Task event.
+    """
+    loop = asyncio.get_event_loop()
+    task_id_future: asyncio.Future[str] = loop.create_future()
+
+    async def _drain() -> None:
+        body = {
+            'jsonrpc': '2.0',
+            'id': str(uuid.uuid4()),
+            'method': 'SendStreamingMessage',
+            'params': MessageToDict(send),
+        }
+        headers = {'A2A-Version': '1.0', 'Accept': 'text/event-stream'}
+        with contextlib.suppress(Exception):
+            async with client.stream(
+                'POST', url, json=body, headers=headers, timeout=120.0
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    if not line.startswith('data:'):
+                        continue
+                    payload = json.loads(line[len('data:') :].strip())
+                    result = payload.get('result')
+                    if result is None:
+                        continue
+                    sr = StreamResponse()
+                    ParseDict(result, sr)
+                    if not task_id_future.done() and sr.HasField('task'):
+                        task_id_future.set_result(sr.task.id)
+
+    drainer = asyncio.create_task(_drain())
+    try:
+        task_id = await asyncio.wait_for(task_id_future, timeout=30)
+    except TimeoutError:
+        drainer.cancel()
+        raise RuntimeError('no task event received from stream') from None
+    return task_id, drainer
+
+
+async def run(host: str, ports: list[int]) -> None:
+    """Runs the cross-replica send / observe / cancel demonstration."""
+    if len(ports) < MIN_REPLICAS:
+        raise SystemExit('Need at least 2 replicas to demonstrate the point.')
+
+    urls = [_endpoint(host, p) for p in ports]
+
+    async with httpx.AsyncClient() as client:
+        # 1) Start a streaming task on replica 0. The stream stays open (agent
+        #    runs) while we observe and cancel from other replicas.
+        print(f'[send]      -> replica 0 ({urls[0]}) (streaming)')
+        send = SendMessageRequest(
+            message=Message(
+                role=Role.ROLE_USER,
+                message_id=str(uuid.uuid4()),
+                parts=[Part(text='hello cluster')],
+            )
+        )
+        task_id, send_call = await _start_streaming(client, urls[0], send)
+        print(f'            task {task_id} started')
+
+        # 2) Poll GetTask from replica 1 until it observes WORKING.
+        print(f'[get]       -> replica 1 ({urls[1]}) while it runs')
+        seen_working = False
+        for _ in range(8):
+            await asyncio.sleep(1.0)
+            try:
+                task = await _get_task(client, urls[1], task_id)
+            except RuntimeError:
+                continue  # not persisted yet
+            print(
+                f'            replica 1 sees state='
+                f'{TaskState.Name(task.status.state)}'
+            )
+            if task.status.state == _WORKING:
+                seen_working = True
+                break
+        if not seen_working:
+            raise RuntimeError('replica 1 never observed the task WORKING')
+
+        # 3) Cancel from a different replica than the one running the agent.
+        cancel_idx = 2 if len(urls) > MIN_REPLICAS else 1
+        print(f'[cancel]    -> replica {cancel_idx} ({urls[cancel_idx]})')
+        result = await _rpc(
+            client,
+            urls[cancel_idx],
+            'CancelTask',
+            CancelTaskRequest(id=task_id),
+        )
+        cancelled = Task()
+        ParseDict(result, cancelled)
+        print(
+            f'            cancel returned state='
+            f'{TaskState.Name(cancelled.status.state)}'
+        )
+
+        # Stop draining the (now-cancelled) stream. CancelledError is a
+        # BaseException, so suppress it explicitly.
+        send_call.cancel()
+        with contextlib.suppress(asyncio.CancelledError, Exception):
+            await send_call
+
+        # 4) Confirm from replica 0 that the cancel is visible everywhere.
+        await asyncio.sleep(1.0)
+        final = await _get_task(client, urls[0], task_id)
+        print(
+            f'[verify]    replica 0 sees final state='
+            f'{TaskState.Name(final.status.state)}'
+        )
+        if final.status.state != _CANCELED:
+            raise RuntimeError(
+                'expected the task to be CANCELED across all replicas, got '
+                f'{TaskState.Name(final.status.state)}'
+            )
+        print(
+            '\nOK: one task was started on replica 0, observed on replica 1, '
+            'and cancelled from another replica -- consistently.'
+        )
+
+
+def main() -> None:
+    """Parses args and runs the demonstration."""
+    parser = argparse.ArgumentParser(description='Exercise an A2A cluster')
+    parser.add_argument('--host', default='127.0.0.1')
+    parser.add_argument(
+        '--ports',
+        default='41241,41242,41243',
+        help='Comma-separated replica ports',
+    )
+    args = parser.parse_args()
+    ports = [int(p) for p in args.ports.split(',')]
+    asyncio.run(run(args.host, ports))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/samples/clustermode/run_cluster.py b/samples/clustermode/run_cluster.py
new file mode 100644
index 000000000..b17b45dab
--- /dev/null
+++ b/samples/clustermode/run_cluster.py
@@ -0,0 +1,88 @@
+"""Launches N cluster-mode replicas as subprocesses on consecutive ports.
+
+Usage:
+    python -m samples.clustermode.run_cluster --replicas 3 --base-port 41241
+
+Each replica shares one database (SQLite file by default). Point any HTTP client
+at any replica's /a2a/jsonrpc endpoint, or use exercise.py which deliberately
+spreads requests for one task across replicas.
+"""
+
+import argparse
+import contextlib
+import os
+import signal
+import subprocess
+import sys
+import time
+
+from pathlib import Path
+
+from samples.clustermode.cluster_common import default_sqlite_path
+
+
+def main() -> None:
+    """Launches N replica subprocesses on consecutive ports."""
+    parser = argparse.ArgumentParser(description='Run an A2A replica cluster')
+    parser.add_argument('--replicas', type=int, default=3)
+    parser.add_argument('--host', default='127.0.0.1')
+    parser.add_argument('--base-port', type=int, default=41241)
+    parser.add_argument('--ticks', type=int, default=10)
+    args = parser.parse_args()
+
+    # A fresh shared SQLite file for this run (unless a DSN is configured).
+    if 'A2A_CLUSTER_DSN' not in os.environ:
+        db_path = os.environ.setdefault(
+            'A2A_CLUSTER_SQLITE', default_sqlite_path()
+        )
+        with contextlib.suppress(FileNotFoundError):
+            Path(db_path).unlink()
+
+    procs: list[subprocess.Popen] = []
+    ports = [args.base_port + i for i in range(args.replicas)]
+    try:
+        for i, port in enumerate(ports):
+            cmd = [
+                sys.executable,
+                '-m',
+                'samples.clustermode.server',
+                '--host',
+                args.host,
+                '--port',
+                str(port),
+                '--replica-id',
+                f'replica-{i}',
+                '--ticks',
+                str(args.ticks),
+            ]
+            procs.append(
+                subprocess.Popen(cmd, env=os.environ.copy())  # noqa: S603
+            )
+            time.sleep(0.5)
+
+        print('\nCluster running. Replica endpoints:')
+        for i, port in enumerate(ports):
+            print(f'  replica-{i}: http://{args.host}:{port}/a2a/jsonrpc')
+        print('\nExercise it with:')
+        joined = ','.join(str(p) for p in ports)
+        print(
+            f'  python -m samples.clustermode.exercise '
+            f'--host {args.host} --ports {joined}'
+        )
+        print('\nPress Ctrl+C to stop.\n')
+
+        for p in procs:
+            p.wait()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        for p in procs:
+            with contextlib.suppress(ProcessLookupError):
+                p.send_signal(signal.SIGINT)
+        for p in procs:
+            with contextlib.suppress(Exception):
+                p.wait(timeout=5)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/samples/clustermode/server.py b/samples/clustermode/server.py
new file mode 100644
index 000000000..8a2d2e0bc
--- /dev/null
+++ b/samples/clustermode/server.py
@@ -0,0 +1,87 @@
+"""A single cluster-mode replica: one FastAPI app on one port.
+
+All replicas share the same database (via A2A_CLUSTER_DSN or the default SQLite
+file), so they form one logical A2A service. Run several of these on different
+ports and put any round-robin in front of them.
+"""
+
+import argparse
+import asyncio
+import contextlib
+import logging
+
+import uvicorn
+
+from fastapi import FastAPI
+
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import (
+    add_a2a_routes_to_fastapi,
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+)
+from samples.clustermode.cluster_common import (
+    SlowEchoAgent,
+    build_agent_card,
+    build_cluster_backends,
+    default_dsn,
+    init_schema,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+async def serve(host: str, port: int, replica_id: str, ticks: int) -> None:
+    """Runs one replica bound to a shared store + event stream."""
+    dsn = default_dsn()
+    await init_schema(dsn)
+
+    base_url = f'http://{host}:{port}'
+    agent_card = build_agent_card(base_url)
+    store, stream = build_cluster_backends(dsn)
+    await store.initialize()
+    await stream.initialize()
+
+    handler = DefaultRequestHandler(
+        agent_executor=SlowEchoAgent(replica_id, ticks=ticks),
+        task_store=store,
+        agent_card=agent_card,
+        event_stream=stream,
+    )
+
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler,
+        rpc_url='/a2a/jsonrpc',
+    )
+    agent_card_routes = create_agent_card_routes(agent_card=agent_card)
+
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(
+        app,
+        agent_card_routes=agent_card_routes,
+        jsonrpc_routes=jsonrpc_routes,
+    )
+
+    logger.info(
+        'Replica %s listening on %s (dsn=%s)', replica_id, base_url, dsn
+    )
+    config = uvicorn.Config(app, host=host, port=port, log_level='warning')
+    await uvicorn.Server(config).serve()
+
+
+def main() -> None:
+    """Parses args and runs one replica."""
+    logging.basicConfig(level=logging.INFO)
+    parser = argparse.ArgumentParser(description='A2A cluster-mode replica')
+    parser.add_argument('--host', default='127.0.0.1')
+    parser.add_argument('--port', type=int, default=41241)
+    parser.add_argument('--replica-id', default='replica-0')
+    parser.add_argument('--ticks', type=int, default=10)
+    args = parser.parse_args()
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(serve(args.host, args.port, args.replica_id, args.ticks))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/samples/hello_world_agent.py b/samples/hello_world_agent.py
new file mode 100644
index 000000000..bf38077dd
--- /dev/null
+++ b/samples/hello_world_agent.py
@@ -0,0 +1,279 @@
+import argparse
+import asyncio
+import contextlib
+import logging
+
+import grpc
+import uvicorn
+
+from fastapi import FastAPI
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2_grpc
+from a2a.compat.v0_3.grpc_handler import CompatGrpcHandler
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler, GrpcHandler
+from a2a.server.routes import (
+    add_a2a_routes_to_fastapi,
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+    Part,
+    Task,
+    TaskState,
+    TaskStatus,
+    a2a_pb2_grpc,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class SampleAgentExecutor(AgentExecutor):
+    """Sample agent executor logic similar to the a2a-js sample."""
+
+    def __init__(self) -> None:
+        self.running_tasks: set[str] = set()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Cancels a task."""
+        task_id = context.task_id
+        if task_id in self.running_tasks:
+            self.running_tasks.remove(task_id)
+
+        updater = TaskUpdater(
+            event_queue=event_queue,
+            task_id=task_id or '',
+            context_id=context.context_id or '',
+        )
+        await updater.cancel()
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Executes a task inline."""
+        user_message = context.message
+        task_id = context.task_id
+        context_id = context.context_id
+
+        if not user_message or not task_id or not context_id:
+            return
+
+        self.running_tasks.add(task_id)
+
+        logger.info(
+            '[SampleAgentExecutor] Processing message %s for task %s (context: %s)',
+            user_message.message_id,
+            task_id,
+            context_id,
+        )
+
+        await event_queue.enqueue_event(
+            Task(
+                id=task_id,
+                context_id=context_id,
+                status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+                history=[user_message],
+            )
+        )
+
+        updater = TaskUpdater(
+            event_queue=event_queue,
+            task_id=task_id,
+            context_id=context_id,
+        )
+
+        working_message = updater.new_agent_message(
+            parts=[Part(text='Processing your question...')]
+        )
+        await updater.start_work(message=working_message)
+
+        query = context.get_user_input()
+
+        agent_reply_text = self._parse_input(query)
+        await asyncio.sleep(1)
+
+        if task_id not in self.running_tasks:
+            return
+
+        await updater.add_artifact(
+            parts=[Part(text=agent_reply_text)],
+            name='response',
+            last_chunk=True,
+        )
+        await updater.complete()
+
+        logger.info(
+            '[SampleAgentExecutor] Task %s finished with state: completed',
+            task_id,
+        )
+
+    def _parse_input(self, query: str) -> str:
+        if not query:
+            return 'Hello! Please provide a message for me to respond to.'
+
+        ql = query.lower()
+        if 'hello' in ql or 'hi' in ql:
+            return 'Hello World! Nice to meet you!'
+        if 'how are you' in ql:
+            return (
+                "I'm doing great! Thanks for asking. How can I help you today?"
+            )
+        if 'goodbye' in ql or 'bye' in ql:
+            return 'Goodbye! Have a wonderful day!'
+        return f"Hello World! You said: '{query}'. Thanks for your message!"
+
+
+async def serve(
+    host: str = '127.0.0.1',
+    port: int = 41241,
+    grpc_port: int = 50051,
+    compat_grpc_port: int = 50052,
+) -> None:
+    """Run the Sample Agent server with mounted JSON-RPC, HTTP+JSON and gRPC transports."""
+    agent_card = AgentCard(
+        name='Sample Agent',
+        description='A sample agent to test the stream functionality.',
+        provider=AgentProvider(
+            organization='A2A Samples', url='https://example.com'
+        ),
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True, push_notifications=False
+        ),
+        default_input_modes=['text'],
+        default_output_modes=['text', 'task-status'],
+        skills=[
+            AgentSkill(
+                id='sample_agent',
+                name='Sample Agent',
+                description='Say hi.',
+                tags=['sample'],
+                examples=['hi'],
+                input_modes=['text'],
+                output_modes=['text', 'task-status'],
+            )
+        ],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding='GRPC',
+                protocol_version='1.0',
+                url=f'{host}:{grpc_port}',
+            ),
+            AgentInterface(
+                protocol_binding='GRPC',
+                protocol_version='0.3',
+                url=f'{host}:{compat_grpc_port}',
+            ),
+            AgentInterface(
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+                url=f'http://{host}:{port}/a2a/jsonrpc',
+            ),
+            AgentInterface(
+                protocol_binding='JSONRPC',
+                protocol_version='0.3',
+                url=f'http://{host}:{port}/a2a/jsonrpc',
+            ),
+            AgentInterface(
+                protocol_binding='HTTP+JSON',
+                protocol_version='1.0',
+                url=f'http://{host}:{port}/a2a/rest',
+            ),
+            AgentInterface(
+                protocol_binding='HTTP+JSON',
+                protocol_version='0.3',
+                url=f'http://{host}:{port}/a2a/rest',
+            ),
+        ],
+    )
+
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandler(
+        agent_executor=SampleAgentExecutor(),
+        task_store=task_store,
+        agent_card=agent_card,
+    )
+
+    rest_routes = create_rest_routes(
+        request_handler=request_handler,
+        path_prefix='/a2a/rest',
+        enable_v0_3_compat=True,
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=request_handler,
+        rpc_url='/a2a/jsonrpc',
+        enable_v0_3_compat=True,
+    )
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card,
+    )
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(
+        app,
+        agent_card_routes=agent_card_routes,
+        jsonrpc_routes=jsonrpc_routes,
+        rest_routes=rest_routes,
+    )
+
+    grpc_server = grpc.aio.server()
+    grpc_server.add_insecure_port(f'{host}:{grpc_port}')
+    servicer = GrpcHandler(request_handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, grpc_server)
+
+    compat_grpc_server = grpc.aio.server()
+    compat_grpc_server.add_insecure_port(f'{host}:{compat_grpc_port}')
+    compat_servicer = CompatGrpcHandler(request_handler)
+    a2a_v0_3_pb2_grpc.add_A2AServiceServicer_to_server(
+        compat_servicer, compat_grpc_server
+    )
+
+    config = uvicorn.Config(app, host=host, port=port)
+    uvicorn_server = uvicorn.Server(config)
+
+    logger.info('Starting Sample Agent servers:')
+    logger.info(' - HTTP on http://%s:%s', host, port)
+    logger.info(' - gRPC on %s:%s', host, grpc_port)
+    logger.info(' - gRPC (v0.3 compat) on %s:%s', host, compat_grpc_port)
+    logger.info(
+        'Agent Card available at http://%s:%s/.well-known/agent-card.json',
+        host,
+        port,
+    )
+
+    await asyncio.gather(
+        grpc_server.start(),
+        compat_grpc_server.start(),
+        uvicorn_server.serve(),
+    )
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    parser = argparse.ArgumentParser(description='Sample A2A agent server')
+    parser.add_argument('--host', default='127.0.0.1')
+    parser.add_argument('--port', type=int, default=41241)
+    parser.add_argument('--grpc-port', type=int, default=50051)
+    parser.add_argument('--compat-grpc-port', type=int, default=50052)
+    args = parser.parse_args()
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(
+            serve(
+                host=args.host,
+                port=args.port,
+                grpc_port=args.grpc_port,
+                compat_grpc_port=args.compat_grpc_port,
+            )
+        )
diff --git a/scripts/docker-compose.test.yml b/scripts/docker-compose.test.yml
new file mode 100644
index 000000000..a2df936e1
--- /dev/null
+++ b/scripts/docker-compose.test.yml
@@ -0,0 +1,29 @@
+services:
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_USER: a2a
+      POSTGRES_PASSWORD: a2a_password
+      POSTGRES_DB: a2a_test
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: a2a_test
+      MYSQL_USER: a2a
+      MYSQL_PASSWORD: a2a_password
+    ports:
+      - "3306:3306"
+    healthcheck:
+      test: ["CMD-SHELL", "mysqladmin ping -h localhost -u root -proot"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
diff --git a/scripts/format.sh b/scripts/format.sh
new file mode 100755
index 000000000..8dcf5e29d
--- /dev/null
+++ b/scripts/format.sh
@@ -0,0 +1,87 @@
+#!/bin/bash
+set -e
+set -o pipefail
+
+# --- Argument Parsing ---
+# Initialize flags
+FORMAT_ALL=false
+RUFF_UNSAFE_FIXES_FLAG=""
+
+# Process command-line arguments
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+    --all)
+        FORMAT_ALL=true
+        echo "Detected --all flag: Formatting all tracked Python files."
+        shift # Consume the argument
+        ;;
+    --unsafe-fixes)
+        RUFF_UNSAFE_FIXES_FLAG="--unsafe-fixes"
+        echo "Detected --unsafe-fixes flag: Ruff will run with unsafe fixes."
+        shift # Consume the argument
+        ;;
+    *)
+        # Handle unknown arguments or just ignore them
+        echo "Warning: Unknown argument '$1'. Ignoring."
+        shift # Consume the argument
+        ;;
+    esac
+done
+
+# Sort Spelling Allowlist
+SPELLING_ALLOW_FILE=".github/actions/spelling/allow.txt"
+if [ -f "$SPELLING_ALLOW_FILE" ]; then
+    echo "Sorting and de-duplicating $SPELLING_ALLOW_FILE"
+    sort -u "$SPELLING_ALLOW_FILE" -o "$SPELLING_ALLOW_FILE"
+fi
+
+CHANGED_FILES=""
+
+if $FORMAT_ALL; then
+    echo "Finding all tracked Python files in the repository..."
+    CHANGED_FILES=$(git ls-files -- '*.py' ':!src/a2a/grpc/*')
+else
+    echo "Finding changed Python files based on git diff..."
+    TARGET_BRANCH="origin/${GITHUB_BASE_REF:-main}"
+    git fetch origin "${GITHUB_BASE_REF:-main}" --depth=1
+
+    MERGE_BASE=$(git merge-base HEAD "$TARGET_BRANCH")
+
+    # Get python files changed in this PR, excluding grpc generated files.
+    CHANGED_FILES=$(git diff --name-only --diff-filter=ACMRTUXB "$MERGE_BASE" HEAD -- '*.py' ':!src/a2a/grpc/*')
+fi
+
+# Exit if no files were found
+if [ -z "$CHANGED_FILES" ]; then
+    echo "No changed or tracked Python files to format."
+    exit 0
+fi
+
+# --- Helper Function ---
+# Runs a command on a list of files passed via stdin.
+# $1: A string containing the list of files (space-separated).
+# $2...: The command and its arguments to run.
+run_formatter() {
+    local files_to_format="$1"
+    shift # Remove the file list from the arguments
+    if [ -n "$files_to_format" ]; then
+        echo "$files_to_format" | xargs -r "$@"
+    fi
+}
+
+# --- Python File Formatting ---
+if [ -n "$CHANGED_FILES" ]; then
+    echo "--- Formatting Python Files ---"
+    echo "Files to be formatted:"
+    echo "$CHANGED_FILES"
+
+    echo "Running ruff check (fix-only)..."
+    run_formatter "$CHANGED_FILES" ruff check --fix-only $RUFF_UNSAFE_FIXES_FLAG
+    echo "Running ruff format..."
+    run_formatter "$CHANGED_FILES" ruff format
+    echo "Python formatting complete."
+else
+    echo "No Python files to format."
+fi
+
+echo "All formatting tasks are complete."
diff --git a/scripts/gen_proto.sh b/scripts/gen_proto.sh
new file mode 100755
index 000000000..34ff96ae0
--- /dev/null
+++ b/scripts/gen_proto.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+set -e
+
+# Run buf generate to regenerate protobuf code and OpenAPI spec
+npx --yes @bufbuild/buf generate
+
+# The OpenAPI generator produces a file named like 'a2a.swagger.json' or similar.
+# We need it to be 'a2a.json' for the A2A SDK.
+# Find the generated json file in the output directory
+generated_json=$(find src/a2a/types -name "*.swagger.json" -print -quit)
+
+if [ -n "$generated_json" ]; then
+    echo "Renaming $generated_json to src/a2a/types/a2a.json"
+    mv "$generated_json" src/a2a/types/a2a.json
+else
+    echo "Warning: No Swagger JSON generated."
+fi
+
+# Fix imports in generated grpc file
+echo "Fixing imports in src/a2a/types/a2a_pb2_grpc.py"
+sed 's/import a2a_pb2 as a2a__pb2/from . import a2a_pb2 as a2a__pb2/g' src/a2a/types/a2a_pb2_grpc.py > src/a2a/types/a2a_pb2_grpc.py.tmp && mv src/a2a/types/a2a_pb2_grpc.py.tmp src/a2a/types/a2a_pb2_grpc.py
+
+# Download legacy v0.3 compatibility protobuf code
+echo "Downloading legacy v0.3 proto file..."
+# Commit hash was selected as a2a.proto version from 0.3 branch with latests fixes.
+curl -o src/a2a/compat/v0_3/a2a_v0_3.proto https://raw.githubusercontent.com/a2aproject/A2A/b3b266d127dde3d1000ec103b252d1de81289e83/specification/grpc/a2a.proto 
+
+
diff --git a/scripts/gen_proto_compat.sh b/scripts/gen_proto_compat.sh
new file mode 100755
index 000000000..c85d2efe2
--- /dev/null
+++ b/scripts/gen_proto_compat.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+# Generate legacy v0.3 compatibility protobuf code
+echo "Generating legacy v0.3 compatibility protobuf code"
+npx --yes @bufbuild/buf generate src/a2a/compat/v0_3 --template buf.compat.gen.yaml
+
+# Fix imports in legacy generated grpc file
+echo "Fixing imports in src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py"
+sed 's/import a2a_v0_3_pb2 as a2a__v0__3__pb2/from . import a2a_v0_3_pb2 as a2a__v0__3__pb2/g' src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py > src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py.tmp && mv src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py.tmp src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py
diff --git a/scripts/lint.sh b/scripts/lint.sh
new file mode 100755
index 000000000..42bb5fc39
--- /dev/null
+++ b/scripts/lint.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+# Local replica of .github/workflows/linter.yaml (excluding jscpd copy-paste check)
+
+# ANSI color codes for premium output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+FAILED=0
+
+echo -e "${BLUE}${BOLD}=== A2A Python Fixed-and-Lint Suite ===${NC}"
+echo -e "Fixing formatting and linting issues, then verifying types...\n"
+
+# 1. Ruff Linter (with fix)
+echo -e "${YELLOW}${BOLD}--- [1/3] Running Ruff Linter (fix) ---${NC}"
+if uv run ruff check --fix; then
+    echo -e "${GREEN}✓ Ruff Linter passed (and fixed what it could)${NC}"
+else
+    echo -e "${RED}✗ Ruff Linter failed${NC}"
+    FAILED=1
+fi
+
+# 2. Ruff Formatter
+echo -e "\n${YELLOW}${BOLD}--- [2/3] Running Ruff Formatter (apply) ---${NC}"
+if uv run ruff format; then
+    echo -e "${GREEN}✓ Ruff Formatter applied${NC}"
+else
+    echo -e "${RED}✗ Ruff Formatter failed${NC}"
+    FAILED=1
+fi
+
+# 3. ty Type Checker
+echo -e "\n${YELLOW}${BOLD}--- [3/3] Running ty Type Checker ---${NC}"
+if uv run ty check; then
+    echo -e "${GREEN}✓ ty passed${NC}"
+else
+    echo -e "${RED}✗ ty failed${NC}"
+    FAILED=1
+fi
+
+echo -e "\n${BLUE}${BOLD}=========================================${NC}"
+if [ $FAILED -eq 0 ]; then
+    echo -e "${GREEN}${BOLD}SUCCESS: All linting and formatting tasks complete!${NC}"
+    exit 0
+else
+    echo -e "${RED}${BOLD}FAILURE: One or more steps failed.${NC}"
+    exit 1
+fi
diff --git a/scripts/run_db_tests.sh b/scripts/run_db_tests.sh
new file mode 100755
index 000000000..ed9a47cb1
--- /dev/null
+++ b/scripts/run_db_tests.sh
@@ -0,0 +1,105 @@
+#!/bin/bash
+set -e
+
+# Get the directory of this script
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+# Docker compose file path
+COMPOSE_FILE="$SCRIPT_DIR/docker-compose.test.yml"
+
+# Initialize variables
+DEBUG_MODE=false
+STOP_MODE=false
+SERVICES=()
+PYTEST_ARGS=()
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --debug)
+      DEBUG_MODE=true
+      shift
+      ;;
+    --stop)
+      STOP_MODE=true
+      shift
+      ;;
+    --postgres)
+      SERVICES+=("postgres")
+      shift
+      ;;
+    --mysql)
+      SERVICES+=("mysql")
+      shift
+      ;;
+    *)
+      # Preserve other arguments for pytest
+      PYTEST_ARGS+=("$1")
+      shift
+      ;;
+  esac
+done
+
+# Handle --stop
+if [[ "$STOP_MODE" == "true" ]]; then
+  echo "Stopping test databases..."
+  docker compose -f "$COMPOSE_FILE" down
+  exit 0
+fi
+
+# Default to running both databases if none specified
+if [[ ${#SERVICES[@]} -eq 0 ]]; then
+  SERVICES=("postgres" "mysql")
+fi
+
+# Cleanup function to stop docker containers
+cleanup() {
+    echo "Stopping test databases..."
+    docker compose -f "$COMPOSE_FILE" down
+}
+
+# Start the databases
+echo "Starting/Verifying databases: ${SERVICES[*]}..."
+docker compose -f "$COMPOSE_FILE" up -d --wait "${SERVICES[@]}"
+
+# Set up environment variables based on active services
+# Only export DSNs for started services so tests skip missing ones
+for service in "${SERVICES[@]}"; do
+  if [[ "$service" == "postgres" ]]; then
+    export POSTGRES_TEST_DSN="postgresql+asyncpg://a2a:a2a_password@localhost:5432/a2a_test"
+  elif [[ "$service" == "mysql" ]]; then
+    export MYSQL_TEST_DSN="mysql+aiomysql://a2a:a2a_password@localhost:3306/a2a_test"
+  fi
+done
+
+# Handle --debug mode
+if [[ "$DEBUG_MODE" == "true" ]]; then
+  echo "---------------------------------------------------"
+  echo "Debug mode enabled. Databases are running."
+  echo "You can connect to them using the following DSNs."
+  echo ""
+  echo "Run the following commands to set up your environment:"
+  echo ""
+  [[ -n "$POSTGRES_TEST_DSN" ]] && echo "export POSTGRES_TEST_DSN=\"$POSTGRES_TEST_DSN\""
+  [[ -n "$MYSQL_TEST_DSN" ]] && echo "export MYSQL_TEST_DSN=\"$MYSQL_TEST_DSN\""
+  echo ""
+  echo "---------------------------------------------------"
+  echo "Run ./scripts/run_integration_tests.sh --stop to shut databases down."
+  exit 0
+fi
+
+# Register cleanup trap for normal test run
+trap cleanup EXIT
+
+# Run the tests
+echo "Running integration tests..."
+cd "$PROJECT_ROOT"
+
+uv run pytest -v \
+    tests/server/tasks/test_database_task_store.py \
+    tests/server/tasks/test_database_push_notification_config_store.py \
+    tests/server/cluster/test_database_versioned_task_store.py \
+    tests/server/cluster/test_database_event_stream.py \
+    tests/integration/test_multiserver.py \
+    "${PYTEST_ARGS[@]}"
diff --git a/scripts/test_install_smoke.sh b/scripts/test_install_smoke.sh
new file mode 100755
index 000000000..fdd9e79a9
--- /dev/null
+++ b/scripts/test_install_smoke.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+# Local equivalent of .github/workflows/install-smoke.yml.
+#
+# For each install profile, builds the wheel and installs it into a
+# clean venv (no dev deps), then runs the smoke test for that profile
+# (imports + any per-profile runtime checks). By default runs every
+# known profile; pass a profile name to run just one.
+#
+# Available profiles (must match those in tests/install_smoke/__main__.py):
+#   base         -- `pip install a2a-sdk`
+#   http-server  -- `pip install a2a-sdk[http-server]`
+#   fastapi      -- `pip install a2a-sdk[fastapi]`
+#   grpc         -- `pip install a2a-sdk[grpc]`
+#   telemetry    -- `pip install a2a-sdk[telemetry]`
+#   sql          -- `pip install a2a-sdk[sql]`
+#
+# Usage:
+#   scripts/test_install_smoke.sh [profile] [python-version]
+#
+# Examples:
+#   scripts/test_install_smoke.sh                       # all profiles, default python
+#   scripts/test_install_smoke.sh '' 3.13               # all profiles on python 3.13
+#   scripts/test_install_smoke.sh http-server           # http-server only
+#   scripts/test_install_smoke.sh http-server 3.13      # http-server on python 3.13
+set -e
+set -o pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_ROOT"
+
+ALL_PROFILES=(base http-server fastapi grpc telemetry sql)
+
+PROFILE_ARG="${1:-}"
+PYTHON_VERSION="${2:-}"
+
+if [ -z "$PROFILE_ARG" ]; then
+    PROFILES=("${ALL_PROFILES[@]}")
+else
+    PROFILES=("$PROFILE_ARG")
+fi
+
+extras_for_profile() {
+    case "$1" in
+        base)        echo "" ;;
+        http-server) echo "[http-server]" ;;
+        fastapi)     echo "[fastapi]" ;;
+        grpc)        echo "[grpc]" ;;
+        telemetry)   echo "[telemetry]" ;;
+        sql)         echo "[sql]" ;;
+        *)
+            echo "Unknown profile '$1'. Available: ${ALL_PROFILES[*]}" >&2
+            return 1
+            ;;
+    esac
+}
+
+# Validate profiles up-front so we fail fast.
+for profile in "${PROFILES[@]}"; do
+    extras_for_profile "$profile" >/dev/null
+done
+
+echo "--- Building wheel ---"
+rm -rf dist
+uv build --wheel
+WHEEL=$(ls dist/*.whl)
+
+FAILED_PROFILES=()
+
+for profile in "${PROFILES[@]}"; do
+    extras=$(extras_for_profile "$profile")
+    venv_dir=".venv-smoke-${profile}"
+
+    echo
+    echo "=================================================================="
+    echo " Profile: $profile  (extras='$extras')"
+    echo "=================================================================="
+
+    echo "--- Creating clean venv at $venv_dir ---"
+    rm -rf "$venv_dir"
+    if [ -n "$PYTHON_VERSION" ]; then
+        uv venv "$venv_dir" --python "$PYTHON_VERSION"
+    else
+        uv venv "$venv_dir"
+    fi
+
+    echo "--- Installing built wheel with '$profile' dependencies only ---"
+    VIRTUAL_ENV="$venv_dir" uv pip install "${WHEEL}${extras}"
+
+    echo "--- Installed packages ---"
+    VIRTUAL_ENV="$venv_dir" uv pip list
+
+    echo "--- Running smoke test (imports + runtime checks) ---"
+    if ! "$venv_dir/bin/python" -m tests.install_smoke "$profile"; then
+        FAILED_PROFILES+=("$profile")
+    fi
+done
+
+echo
+echo "=================================================================="
+if [ ${#FAILED_PROFILES[@]} -eq 0 ]; then
+    echo " All profiles passed: ${PROFILES[*]}"
+    exit 0
+fi
+
+echo " Failed profiles: ${FAILED_PROFILES[*]}" >&2
+exit 1
diff --git a/src/a2a/__init__.py b/src/a2a/__init__.py
index e69de29bb..86893a97a 100644
--- a/src/a2a/__init__.py
+++ b/src/a2a/__init__.py
@@ -0,0 +1 @@
+"""The A2A Python SDK."""
diff --git a/src/a2a/_base.py b/src/a2a/_base.py
new file mode 100644
index 000000000..6c50734cd
--- /dev/null
+++ b/src/a2a/_base.py
@@ -0,0 +1,38 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+def to_camel_custom(snake: str) -> str:
+    """Convert a snake_case string to camelCase.
+
+    Args:
+        snake: The string to convert.
+
+    Returns:
+        The converted camelCase string.
+    """
+    # First, remove any trailing underscores. This is common for names that
+    # conflict with Python keywords, like 'in_' or 'from_'.
+    if snake.endswith('_'):
+        snake = snake.rstrip('_')
+    return to_camel(snake)
+
+
+class A2ABaseModel(BaseModel):
+    """Base class for shared behavior across A2A data models.
+
+    Provides a common configuration (e.g., alias-based population) and
+    serves as the foundation for future extensions or shared utilities.
+
+    This implementation provides backward compatibility for camelCase aliases
+    by lazy-loading an alias map upon first use. Accessing or setting
+    attributes via their camelCase alias will raise a DeprecationWarning.
+    """
+
+    model_config = ConfigDict(
+        # SEE: https://docs.pydantic.dev/latest/api/config/#pydantic.config.ConfigDict.populate_by_name
+        validate_by_name=True,
+        validate_by_alias=True,
+        serialize_by_alias=True,
+        alias_generator=to_camel_custom,
+    )
diff --git a/src/a2a/a2a_db_cli.py b/src/a2a/a2a_db_cli.py
new file mode 100644
index 000000000..1da69a7be
--- /dev/null
+++ b/src/a2a/a2a_db_cli.py
@@ -0,0 +1,164 @@
+import argparse
+import logging
+import os
+
+from importlib.resources import files
+
+
+try:
+    from alembic import command
+    from alembic.config import Config
+
+except ImportError as e:
+    raise ImportError(
+        "CLI requires Alembic. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+
+def _add_shared_args(
+    parser: argparse.ArgumentParser, is_sub: bool = False
+) -> None:
+    """Add common arguments to the given parser."""
+    prefix = 'sub_' if is_sub else ''
+    parser.add_argument(
+        '--database-url',
+        dest=f'{prefix}database_url',
+        help='Database URL to use for the migrations. If not set, the DATABASE_URL environment variable will be used.',
+    )
+    parser.add_argument(
+        '--tasks-table',
+        dest=f'{prefix}tasks_table',
+        help='Custom tasks table to update. If not set, the default is "tasks".',
+    )
+    parser.add_argument(
+        '--push-notification-configs-table',
+        dest=f'{prefix}push_notification_configs_table',
+        help='Custom push notification configs table to update. If not set, the default is "push_notification_configs".',
+    )
+    parser.add_argument(
+        '-v',
+        '--verbose',
+        dest=f'{prefix}verbose',
+        help='Enable verbose output (sets sqlalchemy.engine logging to INFO)',
+        action='store_true',
+    )
+    parser.add_argument(
+        '--sql',
+        dest=f'{prefix}sql',
+        help='Run migrations in sql mode (generate SQL instead of executing)',
+        action='store_true',
+    )
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the argument parser for the migration tool."""
+    parser = argparse.ArgumentParser(description='A2A Database Migration Tool')
+
+    # Global options
+    parser.add_argument(
+        '--add_columns_owner_last_updated-default-owner',
+        dest='owner',
+        help="Value for the 'owner' column (used in specific migrations). If not set defaults to 'legacy_v03_no_user_info'",
+    )
+    _add_shared_args(parser)
+
+    subparsers = parser.add_subparsers(dest='cmd', help='Migration command')
+
+    # Upgrade command
+    up_parser = subparsers.add_parser(
+        'upgrade', help='Upgrade to a later version'
+    )
+    up_parser.add_argument(
+        'revision',
+        nargs='?',
+        default='head',
+        help='Revision target (default: head)',
+    )
+    up_parser.add_argument(
+        '--add_columns_owner_last_updated-default-owner',
+        dest='sub_owner',
+        help="Value for the 'owner' column (used in specific migrations). If not set defaults to 'legacy_v03_no_user_info'",
+    )
+    _add_shared_args(up_parser, is_sub=True)
+
+    # Downgrade command
+    down_parser = subparsers.add_parser(
+        'downgrade', help='Revert to a previous version'
+    )
+    down_parser.add_argument(
+        'revision',
+        nargs='?',
+        default='base',
+        help='Revision target (e.g., -1, base or a specific ID)',
+    )
+    _add_shared_args(down_parser, is_sub=True)
+
+    # Current command
+    current_parser = subparsers.add_parser(
+        'current', help='Display the current revision for a database'
+    )
+    _add_shared_args(current_parser, is_sub=True)
+
+    return parser
+
+
+def run_migrations() -> None:
+    """CLI tool to manage database migrations."""
+    # Configure logging to show INFO messages
+    logging.basicConfig(level=logging.INFO, format='%(levelname)s  %(message)s')
+
+    parser = create_parser()
+    args = parser.parse_args()
+
+    # Default to upgrade head if no command is provided
+    if not args.cmd:
+        args.cmd = 'upgrade'
+        args.revision = 'head'
+
+    # Locate the bundled alembic.ini
+    ini_path = files('a2a').joinpath('alembic.ini')
+    cfg = Config(str(ini_path))
+
+    # Dynamically set the script location
+    migrations_path = files('a2a').joinpath('migrations')
+    cfg.set_main_option('script_location', str(migrations_path))
+
+    # Consolidate owner, db_url, tables, verbose and sql values
+    owner = args.owner or getattr(args, 'sub_owner', None)
+    db_url = args.database_url or getattr(args, 'sub_database_url', None)
+    task_table = args.tasks_table or getattr(args, 'sub_tasks_table', None)
+    push_notification_configs_table = (
+        args.push_notification_configs_table
+        or getattr(args, 'sub_push_notification_configs_table', None)
+    )
+
+    verbose = args.verbose or getattr(args, 'sub_verbose', False)
+    sql = args.sql or getattr(args, 'sub_sql', False)
+
+    # Pass custom arguments to the migration context
+    if owner:
+        cfg.set_main_option(
+            'add_columns_owner_last_updated_default_owner', owner
+        )
+    if db_url:
+        os.environ['DATABASE_URL'] = db_url
+    if task_table:
+        cfg.set_main_option('tasks_table', task_table)
+    if push_notification_configs_table:
+        cfg.set_main_option(
+            'push_notification_configs_table', push_notification_configs_table
+        )
+    if verbose:
+        cfg.set_main_option('verbose', 'true')
+
+    # Execute the requested command
+    if args.cmd == 'upgrade':
+        logging.info('Upgrading database to %s', args.revision)
+        command.upgrade(cfg, args.revision, sql=sql)
+    elif args.cmd == 'downgrade':
+        logging.info('Downgrading database to %s', args.revision)
+        command.downgrade(cfg, args.revision, sql=sql)
+    elif args.cmd == 'current':
+        command.current(cfg, verbose=verbose)
+
+    logging.info('Done.')
diff --git a/src/a2a/alembic.ini b/src/a2a/alembic.ini
new file mode 100644
index 000000000..f46511c00
--- /dev/null
+++ b/src/a2a/alembic.ini
@@ -0,0 +1,35 @@
+# A generic, single database configuration.
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = INFO
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = WARNING
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
diff --git a/src/a2a/auth/__init__.py b/src/a2a/auth/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/a2a/auth/user.py b/src/a2a/auth/user.py
new file mode 100644
index 000000000..8b6bf08ec
--- /dev/null
+++ b/src/a2a/auth/user.py
@@ -0,0 +1,31 @@
+"""Authenticated user information."""
+
+from abc import ABC, abstractmethod
+
+
+class User(ABC):
+    """A representation of an authenticated user."""
+
+    @property
+    @abstractmethod
+    def is_authenticated(self) -> bool:
+        """Returns whether the current user is authenticated."""
+
+    @property
+    @abstractmethod
+    def user_name(self) -> str:
+        """Returns the user name of the current user."""
+
+
+class UnauthenticatedUser(User):
+    """A representation that no user has been authenticated in the request."""
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Returns whether the current user is authenticated."""
+        return False
+
+    @property
+    def user_name(self) -> str:
+        """Returns the user name of the current user."""
+        return ''
diff --git a/src/a2a/client/__init__.py b/src/a2a/client/__init__.py
index 1be94a76d..d33c09481 100644
--- a/src/a2a/client/__init__.py
+++ b/src/a2a/client/__init__.py
@@ -1,17 +1,44 @@
-from a2a.client.client import A2ACardResolver, A2AClient
+"""Client-side components for interacting with an A2A agent."""
+
+from a2a.client.auth import (
+    AuthInterceptor,
+    CredentialService,
+    InMemoryContextCredentialStore,
+)
+from a2a.client.base_client import BaseClient
+from a2a.client.card_resolver import A2ACardResolver
+from a2a.client.client import (
+    Client,
+    ClientCallContext,
+    ClientConfig,
+)
+from a2a.client.client_factory import (
+    ClientFactory,
+    create_client,
+    minimal_agent_card,
+)
 from a2a.client.errors import (
     A2AClientError,
-    A2AClientHTTPError,
-    A2AClientJSONError,
+    A2AClientTimeoutError,
+    AgentCardResolutionError,
 )
-from a2a.client.helpers import create_text_message_object
+from a2a.client.interceptors import ClientCallInterceptor
 
 
 __all__ = [
     'A2ACardResolver',
-    'A2AClient',
     'A2AClientError',
-    'A2AClientHTTPError',
-    'A2AClientJSONError',
-    'create_text_message_object',
+    'A2AClientTimeoutError',
+    'AgentCardResolutionError',
+    'AuthInterceptor',
+    'BaseClient',
+    'Client',
+    'ClientCallContext',
+    'ClientCallInterceptor',
+    'ClientConfig',
+    'ClientFactory',
+    'CredentialService',
+    'InMemoryContextCredentialStore',
+    'create_client',
+    'minimal_agent_card',
 ]
diff --git a/src/a2a/client/auth/__init__.py b/src/a2a/client/auth/__init__.py
new file mode 100644
index 000000000..8efe65fc0
--- /dev/null
+++ b/src/a2a/client/auth/__init__.py
@@ -0,0 +1,14 @@
+"""Client-side authentication components for the A2A Python SDK."""
+
+from a2a.client.auth.credentials import (
+    CredentialService,
+    InMemoryContextCredentialStore,
+)
+from a2a.client.auth.interceptor import AuthInterceptor
+
+
+__all__ = [
+    'AuthInterceptor',
+    'CredentialService',
+    'InMemoryContextCredentialStore',
+]
diff --git a/src/a2a/client/auth/credentials.py b/src/a2a/client/auth/credentials.py
new file mode 100644
index 000000000..e3d74e4af
--- /dev/null
+++ b/src/a2a/client/auth/credentials.py
@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+
+from a2a.client.client import ClientCallContext
+
+
+class CredentialService(ABC):
+    """An abstract service for retrieving credentials."""
+
+    @abstractmethod
+    async def get_credentials(
+        self,
+        security_scheme_name: str,
+        context: ClientCallContext | None,
+    ) -> str | None:
+        """
+        Retrieves a credential (e.g., token) for a security scheme.
+        """
+
+
+class InMemoryContextCredentialStore(CredentialService):
+    """A simple in-memory store for session-keyed credentials.
+
+    This class uses the 'sessionId' from the ClientCallContext state to
+    store and retrieve credentials...
+    """
+
+    def __init__(self) -> None:
+        self._store: dict[str, dict[str, str]] = {}
+
+    async def get_credentials(
+        self,
+        security_scheme_name: str,
+        context: ClientCallContext | None,
+    ) -> str | None:
+        """Retrieves credentials from the in-memory store.
+
+        Args:
+            security_scheme_name: The name of the security scheme.
+            context: The client call context.
+
+        Returns:
+            The credential string, or None if not found.
+        """
+        if not context or 'sessionId' not in context.state:
+            return None
+        session_id = context.state['sessionId']
+        return self._store.get(session_id, {}).get(security_scheme_name)
+
+    async def set_credentials(
+        self, session_id: str, security_scheme_name: str, credential: str
+    ) -> None:
+        """Method to populate the store."""
+        if session_id not in self._store:
+            self._store[session_id] = {}
+        self._store[session_id][security_scheme_name] = credential
diff --git a/src/a2a/client/auth/interceptor.py b/src/a2a/client/auth/interceptor.py
new file mode 100644
index 000000000..973c91cd7
--- /dev/null
+++ b/src/a2a/client/auth/interceptor.py
@@ -0,0 +1,96 @@
+import logging  # noqa: I001
+
+from a2a.client.auth.credentials import CredentialService
+from a2a.client.client import ClientCallContext
+from a2a.client.interceptors import (
+    AfterArgs,
+    BeforeArgs,
+    ClientCallInterceptor,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AuthInterceptor(ClientCallInterceptor):
+    """An interceptor that automatically adds authentication details to requests.
+
+    Based on the agent's security schemes.
+    """
+
+    def __init__(self, credential_service: CredentialService):
+        self._credential_service = credential_service
+
+    async def before(self, args: BeforeArgs) -> None:
+        """Applies authentication headers to the request if credentials are available."""
+        agent_card = args.agent_card
+
+        # Proto3 repeated fields (security) and maps (security_schemes) do not track presence.
+        # HasField() raises ValueError for them.
+        # We check for truthiness to see if they are non-empty.
+        if (
+            not agent_card.security_requirements
+            or not agent_card.security_schemes
+        ):
+            return
+
+        for requirement in agent_card.security_requirements:
+            for scheme_name in requirement.schemes:
+                credential = await self._credential_service.get_credentials(
+                    scheme_name, args.context
+                )
+                if credential and scheme_name in agent_card.security_schemes:
+                    scheme = agent_card.security_schemes[scheme_name]
+
+                    if args.context is None:
+                        args.context = ClientCallContext()
+
+                    if args.context.service_parameters is None:
+                        args.context.service_parameters = {}
+
+                    # HTTP Bearer authentication
+                    if (
+                        scheme.HasField('http_auth_security_scheme')
+                        and scheme.http_auth_security_scheme.scheme.lower()
+                        == 'bearer'
+                    ):
+                        args.context.service_parameters['Authorization'] = (
+                            f'Bearer {credential}'
+                        )
+                        logger.debug(
+                            "Added Bearer token for scheme '%s'.",
+                            scheme_name,
+                        )
+                        return
+
+                    # OAuth2 and OIDC schemes are implicitly Bearer
+                    if scheme.HasField(
+                        'oauth2_security_scheme'
+                    ) or scheme.HasField('open_id_connect_security_scheme'):
+                        args.context.service_parameters['Authorization'] = (
+                            f'Bearer {credential}'
+                        )
+                        logger.debug(
+                            "Added Bearer token for scheme '%s'.",
+                            scheme_name,
+                        )
+                        return
+
+                    # API Key in Header
+                    if (
+                        scheme.HasField('api_key_security_scheme')
+                        and scheme.api_key_security_scheme.location.lower()
+                        == 'header'
+                    ):
+                        args.context.service_parameters[
+                            scheme.api_key_security_scheme.name
+                        ] = credential
+                        logger.debug(
+                            "Added API Key Header for scheme '%s'.",
+                            scheme_name,
+                        )
+                        return
+
+                # Note: Other cases like API keys in query/cookie are not handled and will be skipped.
+
+    async def after(self, args: AfterArgs) -> None:
+        """Invoked after the method is executed."""
diff --git a/src/a2a/client/base_client.py b/src/a2a/client/base_client.py
new file mode 100644
index 000000000..fbcdb955e
--- /dev/null
+++ b/src/a2a/client/base_client.py
@@ -0,0 +1,612 @@
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
+from contextlib import aclosing
+from typing import Any
+
+from a2a.client.client import (
+    Client,
+    ClientCallContext,
+    ClientConfig,
+)
+from a2a.client.interceptors import (
+    AfterArgs,
+    BeforeArgs,
+    ClientCallInterceptor,
+)
+from a2a.client.transports.base import ClientTransport
+from a2a.plugins.manager import PluginManager, get_global
+from a2a.plugins.types import ClientRequest, ClientResponse
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+
+
+class BaseClient(Client):
+    """Base implementation of the A2A client, containing transport-independent logic.
+
+    Client plugin hooks run around every call: ``before_client_request`` before
+    the interceptors, ``after_client_request`` after them.
+    """
+
+    def __init__(
+        self,
+        card: AgentCard,
+        config: ClientConfig,
+        transport: ClientTransport,
+        interceptors: list[ClientCallInterceptor],
+        *,
+        plugins: PluginManager | None = None,
+    ):
+        """Initializes the client.
+
+        Args:
+            card: The card of the agent to call.
+            config: The client configuration.
+            transport: The transport used for calls.
+            interceptors: Interceptors applied to every call.
+            plugins: Plugin manager whose client hooks run for every call.
+                Defaults to the global manager at construction time.
+        """
+        super().__init__(interceptors)
+        self._card = card
+        self._config = config
+        self._transport = transport
+        self._interceptors = interceptors
+        self._plugins = plugins if plugins is not None else get_global()
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncIterator[StreamResponse]:
+        """Sends a message to the agent.
+
+        This method handles both streaming and non-streaming (polling) interactions
+        based on the client configuration and agent capabilities. It will yield
+        events as they are received from the agent.
+
+        Args:
+            request: The message to send to the agent.
+            context: Optional client call context.
+
+        Yields:
+            An async iterator of `StreamResponse`
+        """
+        self._apply_client_config(request)
+        if not self._config.streaming or not self._card.capabilities.streaming:
+            response = await self._execute_with_interceptors(
+                input_data=request,
+                method='send_message',
+                context=context,
+                transport_call=lambda req, ctx: self._transport.send_message(
+                    req, context=ctx
+                ),
+            )
+
+            # In non-streaming case we convert to a StreamResponse so that the
+            # client always sees the same iterator.
+            stream_response = StreamResponse()
+            if response.HasField('task'):
+                stream_response.task.CopyFrom(response.task)
+            elif response.HasField('message'):
+                stream_response.message.CopyFrom(response.message)
+            else:
+                raise ValueError('Response has neither task nor message')
+
+            yield stream_response
+            return
+
+        # aclosing() closes the inner stream (and the transport stream) as
+        # soon as the caller stops iterating.
+        async with aclosing(
+            self._execute_stream_with_interceptors(
+                input_data=request,
+                method='send_message_streaming',
+                context=context,
+                transport_call=lambda req, ctx: (
+                    self._transport.send_message_streaming(req, context=ctx)
+                ),
+            )
+        ) as events:
+            async for event in events:
+                yield event
+
+    def _apply_client_config(self, request: SendMessageRequest) -> None:
+        request.configuration.return_immediately |= self._config.polling
+        if (
+            not request.configuration.HasField('task_push_notification_config')
+            and self._config.push_notification_config
+        ):
+            request.configuration.task_push_notification_config.CopyFrom(
+                self._config.push_notification_config
+            )
+        if (
+            not request.configuration.accepted_output_modes
+            and self._config.accepted_output_modes
+        ):
+            request.configuration.accepted_output_modes.extend(
+                self._config.accepted_output_modes
+            )
+
+    async def _process_stream(
+        self,
+        stream: AsyncIterator[StreamResponse],
+        before_args: BeforeArgs,
+    ) -> AsyncGenerator[StreamResponse, None]:
+        async for stream_response in stream:
+            after_args = AfterArgs(
+                result=stream_response,
+                method=before_args.method,
+                agent_card=self._card,
+                context=before_args.context,
+            )
+            await self._intercept_after(after_args)
+            yield after_args.result
+            if after_args.result.HasField('message'):
+                return
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task.
+
+        Args:
+            request: The `GetTaskRequest` object specifying the task ID.
+            context: Optional client call context.
+
+        Returns:
+            A `Task` object representing the current state of the task.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='get_task',
+            context=context,
+            transport_call=lambda req, ctx: self._transport.get_task(
+                req, context=ctx
+            ),
+        )
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='list_tasks',
+            context=context,
+            transport_call=lambda req, ctx: self._transport.list_tasks(
+                req, context=ctx
+            ),
+        )
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task.
+
+        Args:
+            request: The `CancelTaskRequest` object specifying the task ID.
+            context: Optional client call context.
+
+        Returns:
+            A `Task` object containing the updated task status.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='cancel_task',
+            context=context,
+            transport_call=lambda req, ctx: self._transport.cancel_task(
+                req, context=ctx
+            ),
+        )
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task.
+
+        Args:
+            request: The `TaskPushNotificationConfig` object with the new configuration.
+            context: Optional client call context.
+
+        Returns:
+            The created or updated `TaskPushNotificationConfig` object.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='create_task_push_notification_config',
+            context=context,
+            transport_call=lambda req, ctx: (
+                self._transport.create_task_push_notification_config(
+                    req, context=ctx
+                )
+            ),
+        )
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task.
+
+        Args:
+            request: The `GetTaskPushNotificationConfigParams` object specifying the task.
+            context: Optional client call context.
+
+        Returns:
+            A `TaskPushNotificationConfig` object containing the configuration.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='get_task_push_notification_config',
+            context=context,
+            transport_call=lambda req, ctx: (
+                self._transport.get_task_push_notification_config(
+                    req, context=ctx
+                )
+            ),
+        )
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task.
+
+        Args:
+            request: The `ListTaskPushNotificationConfigsRequest` object specifying the request.
+            context: Optional client call context.
+
+        Returns:
+            A `ListTaskPushNotificationConfigsResponse` object.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='list_task_push_notification_configs',
+            context=context,
+            transport_call=lambda req, ctx: (
+                self._transport.list_task_push_notification_configs(
+                    req, context=ctx
+                )
+            ),
+        )
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task.
+
+        Args:
+            request: The `DeleteTaskPushNotificationConfigRequest` object specifying the request.
+            context: Optional client call context.
+        """
+        return await self._execute_with_interceptors(
+            input_data=request,
+            method='delete_task_push_notification_config',
+            context=context,
+            transport_call=lambda req, ctx: (
+                self._transport.delete_task_push_notification_config(
+                    req, context=ctx
+                )
+            ),
+        )
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncIterator[StreamResponse]:
+        """Resubscribes to a task's event stream.
+
+        This is only available if both the client and server support streaming.
+
+        Args:
+            request: Parameters to identify the task to resubscribe to.
+            context: Optional client call context.
+
+        Yields:
+            An async iterator of `StreamResponse` objects.
+
+        Raises:
+            NotImplementedError: If streaming is not supported by the client or server.
+        """
+        if not self._config.streaming or not self._card.capabilities.streaming:
+            raise NotImplementedError(
+                'client and/or server do not support resubscription.'
+            )
+
+        async with aclosing(
+            self._execute_stream_with_interceptors(
+                input_data=request,
+                method='subscribe',
+                context=context,
+                transport_call=lambda req, ctx: self._transport.subscribe(
+                    req, context=ctx
+                ),
+            )
+        ) as events:
+            async for event in events:
+                yield event
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+        signature_verifier: Callable[[AgentCard], None] | None = None,
+    ) -> AgentCard:
+        """Retrieves the agent's card.
+
+        This will fetch the authenticated card if necessary and update the
+        client's internal state with the new card.
+
+        Args:
+            request: The `GetExtendedAgentCardRequest` object specifying the request.
+            context: Optional client call context.
+            signature_verifier: A callable used to verify the agent card's signatures.
+
+        Returns:
+            The `AgentCard` for the agent.
+        """
+        card = await self._execute_with_interceptors(
+            input_data=request,
+            method='get_extended_agent_card',
+            context=context,
+            transport_call=lambda req, ctx: (
+                self._transport.get_extended_agent_card(req, context=ctx)
+            ),
+        )
+        if signature_verifier:
+            signature_verifier(card)
+
+        self._card = card
+        return card
+
+    async def close(self) -> None:
+        """Closes the underlying transport."""
+        await self._transport.close()
+
+    def _client_request(
+        self,
+        input_data: Any,
+        method: str,
+        context: ClientCallContext | None,
+    ) -> ClientRequest:
+        return ClientRequest(
+            method=method,
+            payload=input_data,
+            agent_card=self._card,
+            context=context if context is not None else ClientCallContext(),
+        )
+
+    async def _execute_with_interceptors(
+        self,
+        input_data: Any,
+        method: str,
+        context: ClientCallContext | None,
+        transport_call: Callable[
+            [Any, ClientCallContext | None], Awaitable[Any]
+        ],
+    ) -> Any:
+        """Runs a unary call through plugins, interceptors and the transport.
+
+        ``method`` is reported to both plugins and interceptors.
+        """
+        plugins = self._plugins
+        if not plugins.has_client_hooks:
+            return await self._call_through_interceptors(
+                input_data, method, context, transport_call
+            )
+
+        request = self._client_request(input_data, method, context)
+        await plugins.before_client_request(request)
+        try:
+            result = await self._call_through_interceptors(
+                request.payload, method, request.context, transport_call
+            )
+        except Exception as e:
+            await plugins.after_client_request(
+                ClientResponse(request.method, None, request.context, error=e)
+            )
+            raise
+        await plugins.after_client_request(
+            ClientResponse(request.method, result, request.context)
+        )
+        return result
+
+    async def _call_through_interceptors(
+        self,
+        input_data: Any,
+        method: str,
+        context: ClientCallContext | None,
+        transport_call: Callable[
+            [Any, ClientCallContext | None], Awaitable[Any]
+        ],
+    ) -> Any:
+        before_args = BeforeArgs(
+            input=input_data,
+            method=method,
+            agent_card=self._card,
+            context=context,
+        )
+        before_result = await self._intercept_before(before_args)
+
+        if before_result is not None:
+            early_after_args = AfterArgs(
+                result=before_result['early_return'],
+                method=method,
+                agent_card=self._card,
+                context=before_args.context,
+            )
+            await self._intercept_after(
+                early_after_args,
+                before_result['executed'],
+            )
+            return early_after_args.result
+
+        result = await transport_call(before_args.input, before_args.context)
+
+        after_args = AfterArgs(
+            result=result,
+            method=method,
+            agent_card=self._card,
+            context=before_args.context,
+        )
+        await self._intercept_after(after_args)
+
+        return after_args.result
+
+    async def _execute_stream_with_interceptors(
+        self,
+        input_data: Any,
+        method: str,
+        context: ClientCallContext | None,
+        transport_call: Callable[
+            [Any, ClientCallContext | None], AsyncIterator[StreamResponse]
+        ],
+    ) -> AsyncGenerator[StreamResponse, None]:
+        """Runs a streaming call through plugins, interceptors and the transport.
+
+        ``method`` is reported to both plugins and interceptors.
+        """
+        plugins = self._plugins
+        if not plugins.has_client_hooks:
+            async with aclosing(
+                self._stream_through_interceptors(
+                    input_data, method, context, transport_call
+                )
+            ) as events:
+                async for event in events:
+                    yield event
+            return
+
+        request = self._client_request(input_data, method, context)
+        await plugins.before_client_request(request)
+        error: BaseException | None = None
+        try:
+            async with aclosing(
+                self._stream_through_interceptors(
+                    request.payload, method, request.context, transport_call
+                )
+            ) as events:
+                async for event in events:
+                    await plugins.after_client_request(
+                        ClientResponse(
+                            request.method,
+                            event,
+                            request.context,
+                            is_stream_event=True,
+                            is_final=False,
+                        )
+                    )
+                    yield event
+        except Exception as e:
+            error = e
+            raise
+        finally:
+            # Also runs when the caller stops iterating early.
+            await plugins.after_client_request(
+                ClientResponse(
+                    request.method, None, request.context, error=error
+                )
+            )
+
+    async def _stream_through_interceptors(
+        self,
+        input_data: Any,
+        method: str,
+        context: ClientCallContext | None,
+        transport_call: Callable[
+            [Any, ClientCallContext | None], AsyncIterator[StreamResponse]
+        ],
+    ) -> AsyncGenerator[StreamResponse, None]:
+        before_args = BeforeArgs(
+            input=input_data,
+            method=method,
+            agent_card=self._card,
+            context=context,
+        )
+        before_result = await self._intercept_before(before_args)
+
+        if before_result is not None:
+            after_args = AfterArgs(
+                result=before_result['early_return'],
+                method=method,
+                agent_card=self._card,
+                context=before_args.context,
+            )
+            await self._intercept_after(after_args, before_result['executed'])
+
+            yield after_args.result
+            return
+
+        stream = transport_call(before_args.input, before_args.context)
+
+        async for client_event in self._process_stream(stream, before_args):
+            yield client_event
+
+    async def _intercept_before(
+        self,
+        args: BeforeArgs,
+    ) -> dict[str, Any] | None:
+        if not self._interceptors:
+            return None
+        executed: list[ClientCallInterceptor] = []
+        for interceptor in self._interceptors:
+            await interceptor.before(args)
+            executed.append(interceptor)
+            if args.early_return:
+                return {
+                    'early_return': args.early_return,
+                    'executed': executed,
+                }
+        return None
+
+    async def _intercept_after(
+        self,
+        args: AfterArgs,
+        interceptors: list[ClientCallInterceptor] | None = None,
+    ) -> None:
+        interceptors_to_use = (
+            interceptors if interceptors is not None else self._interceptors
+        )
+
+        reversed_interceptors = list(reversed(interceptors_to_use))
+        for interceptor in reversed_interceptors:
+            await interceptor.after(args)
+            if args.early_return:
+                return
diff --git a/src/a2a/client/card_resolver.py b/src/a2a/client/card_resolver.py
new file mode 100644
index 000000000..447913572
--- /dev/null
+++ b/src/a2a/client/card_resolver.py
@@ -0,0 +1,221 @@
+import json
+import logging
+
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+
+from google.protobuf.json_format import ParseDict, ParseError
+
+from a2a.client.errors import AgentCardResolutionError
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+)
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+
+
+logger = logging.getLogger(__name__)
+
+
+def parse_agent_card(agent_card_data: dict[str, Any]) -> AgentCard:
+    """Parse AgentCard JSON dictionary and handle backward compatibility."""
+    if not isinstance(agent_card_data, dict):
+        raise ParseError('Agent card must be a JSON object')
+    try:
+        _handle_extended_card_compatibility(agent_card_data)
+        _handle_connection_fields_compatibility(agent_card_data)
+        _handle_security_compatibility(agent_card_data)
+    except (TypeError, AttributeError) as e:
+        raise ParseError(f'Invalid agent card structure: {e}') from e
+
+    return ParseDict(agent_card_data, AgentCard(), ignore_unknown_fields=True)
+
+
+def _handle_extended_card_compatibility(
+    agent_card_data: dict[str, Any],
+) -> None:
+    """Map legacy supportsAuthenticatedExtendedCard to capabilities."""
+    if agent_card_data.pop('supportsAuthenticatedExtendedCard', None):
+        capabilities = agent_card_data.setdefault('capabilities', {})
+        if 'extendedAgentCard' not in capabilities:
+            capabilities['extendedAgentCard'] = True
+
+
+def _handle_connection_fields_compatibility(
+    agent_card_data: dict[str, Any],
+) -> None:
+    """Map legacy connection and transport fields to supportedInterfaces."""
+    main_url = agent_card_data.pop('url', None)
+    main_transport = agent_card_data.pop('preferredTransport', 'JSONRPC')
+    version = agent_card_data.pop('protocolVersion', '0.3.0')
+    additional_interfaces = (
+        agent_card_data.pop('additionalInterfaces', None) or []
+    )
+
+    if 'supportedInterfaces' not in agent_card_data and main_url:
+        supported_interfaces = []
+        supported_interfaces.append(
+            {
+                'url': main_url,
+                'protocolBinding': main_transport,
+                'protocolVersion': version,
+            }
+        )
+        supported_interfaces.extend(
+            {
+                'url': iface.get('url'),
+                'protocolBinding': iface.get('transport'),
+                'protocolVersion': version,
+            }
+            for iface in additional_interfaces
+        )
+        agent_card_data['supportedInterfaces'] = supported_interfaces
+
+
+def _map_legacy_security(
+    sec_list: list[dict[str, list[str]]],
+) -> list[dict[str, Any]]:
+    """Convert a legacy security requirement list into the 1.0.0 Protobuf format."""
+    return [
+        {
+            'schemes': {
+                scheme_name: {'list': scopes}
+                for scheme_name, scopes in sec_dict.items()
+            }
+        }
+        for sec_dict in sec_list
+    ]
+
+
+def _handle_security_compatibility(agent_card_data: dict[str, Any]) -> None:
+    """Map legacy security requirements and schemas to their 1.0.0 Protobuf equivalents."""
+    legacy_security = agent_card_data.pop('security', None)
+    if (
+        'securityRequirements' not in agent_card_data
+        and legacy_security is not None
+    ):
+        agent_card_data['securityRequirements'] = _map_legacy_security(
+            legacy_security
+        )
+
+    for skill in agent_card_data.get('skills', []):
+        legacy_skill_sec = skill.pop('security', None)
+        if 'securityRequirements' not in skill and legacy_skill_sec is not None:
+            skill['securityRequirements'] = _map_legacy_security(
+                legacy_skill_sec
+            )
+
+    security_schemes = agent_card_data.get('securitySchemes', {})
+    if security_schemes:
+        type_mapping = {
+            'apiKey': 'apiKeySecurityScheme',
+            'http': 'httpAuthSecurityScheme',
+            'oauth2': 'oauth2SecurityScheme',
+            'openIdConnect': 'openIdConnectSecurityScheme',
+            'mutualTLS': 'mtlsSecurityScheme',
+        }
+        for scheme in security_schemes.values():
+            scheme_type = scheme.pop('type', None)
+            if scheme_type in type_mapping:
+                # Map legacy 'in' to modern 'location'
+                if scheme_type == 'apiKey' and 'in' in scheme:
+                    scheme['location'] = scheme.pop('in')
+
+                mapped_name = type_mapping[scheme_type]
+                new_scheme_wrapper = {mapped_name: scheme.copy()}
+                scheme.clear()
+                scheme.update(new_scheme_wrapper)
+
+
+class A2ACardResolver:
+    """Agent Card resolver."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        base_url: str,
+        agent_card_path: str = AGENT_CARD_WELL_KNOWN_PATH,
+    ) -> None:
+        """Initializes the A2ACardResolver.
+
+        Args:
+            httpx_client: An async HTTP client instance (e.g., httpx.AsyncClient).
+            base_url: The base URL of the agent's host.
+            agent_card_path: The path to the agent card endpoint, relative to the base URL.
+        """
+        self.base_url = base_url.rstrip('/')
+        self.agent_card_path = agent_card_path.lstrip('/')
+        self.httpx_client = httpx_client
+
+    async def get_agent_card(
+        self,
+        relative_card_path: str | None = None,
+        http_kwargs: dict[str, Any] | None = None,
+        signature_verifier: Callable[[AgentCard], None] | None = None,
+    ) -> AgentCard:
+        """Fetches an agent card from a specified path relative to the base_url.
+
+        If relative_card_path is None, it defaults to the resolver's configured
+        agent_card_path (for the public agent card).
+
+        Args:
+            relative_card_path: Optional path to the agent card endpoint,
+                relative to the base URL. If None, uses the default public
+                agent card path. Use `'/'` for an empty path.
+            http_kwargs: Optional dictionary of keyword arguments to pass to the
+                underlying httpx.get request.
+            signature_verifier: A callable used to verify the agent card's signatures.
+
+        Returns:
+            An `AgentCard` object representing the agent's capabilities.
+
+        Raises:
+            AgentCardResolutionError: If an HTTP error occurs during the request, if the
+                response body cannot be decoded as JSON, or if it cannot be
+                validated against the AgentCard schema.
+        """
+        if not relative_card_path:
+            # Use the default public agent card path configured during initialization
+            path_segment = self.agent_card_path
+        else:
+            path_segment = relative_card_path.lstrip('/')
+
+        target_url = (
+            f'{self.base_url}/{path_segment}' if path_segment else self.base_url
+        )
+
+        try:
+            response = await self.httpx_client.get(
+                target_url,
+                **(http_kwargs or {}),
+            )
+            response.raise_for_status()
+            agent_card_data = response.json()
+            logger.info(
+                'Successfully fetched agent card data from %s: %s',
+                target_url,
+                agent_card_data,
+            )
+            agent_card = parse_agent_card(agent_card_data)
+            if signature_verifier:
+                signature_verifier(agent_card)
+        except httpx.HTTPStatusError as e:
+            raise AgentCardResolutionError(
+                f'Failed to fetch agent card from {target_url} (HTTP {e.response.status_code}): {e}',
+                status_code=e.response.status_code,
+            ) from e
+        except json.JSONDecodeError as e:
+            raise AgentCardResolutionError(
+                f'Failed to parse JSON for agent card from {target_url}: {e}'
+            ) from e
+        except httpx.RequestError as e:
+            raise AgentCardResolutionError(
+                f'Network communication error fetching agent card from {target_url}: {e}',
+            ) from e
+        except ParseError as e:
+            raise AgentCardResolutionError(
+                f'Failed to validate agent card structure from {target_url}: {e}'
+            ) from e
+
+        return agent_card
diff --git a/src/a2a/client/client.py b/src/a2a/client/client.py
index 2f0327077..3fbf4f287 100644
--- a/src/a2a/client/client.py
+++ b/src/a2a/client/client.py
@@ -1,234 +1,228 @@
-import json
+import dataclasses
+import logging
 
-from collections.abc import AsyncGenerator
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Callable, MutableMapping
+from types import TracebackType
 from typing import Any
-from uuid import uuid4
 
 import httpx
 
-from httpx_sse import SSEError, aconnect_sse
+from pydantic import BaseModel, Field
+from typing_extensions import Self
 
-from a2a.client.errors import A2AClientHTTPError, A2AClientJSONError
-from a2a.types import (
+from a2a.client.interceptors import ClientCallInterceptor
+from a2a.client.optionals import Channel
+from a2a.client.service_parameters import ServiceParameters
+from a2a.types.a2a_pb2 import (
     AgentCard,
     CancelTaskRequest,
-    CancelTaskResponse,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
     GetTaskPushNotificationConfigRequest,
-    GetTaskPushNotificationConfigResponse,
     GetTaskRequest,
-    GetTaskResponse,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
     SendMessageRequest,
-    SendMessageResponse,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
-    SetTaskPushNotificationConfigRequest,
-    SetTaskPushNotificationConfigResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
 )
 
 
-class A2ACardResolver:
-    """Agent Card resolver."""
+logger = logging.getLogger(__name__)
 
-    def __init__(
-        self,
-        httpx_client: httpx.AsyncClient,
-        base_url: str,
-        agent_card_path: str = '/.well-known/agent.json',
-    ):
-        self.base_url = base_url.rstrip('/')
-        self.agent_card_path = agent_card_path.lstrip('/')
-        self.httpx_client = httpx_client
 
-    async def get_agent_card(
-        self, http_kwargs: dict[str, Any] | None = None
-    ) -> AgentCard:
-        try:
-            response = await self.httpx_client.get(
-                f'{self.base_url}/{self.agent_card_path}',
-                **(http_kwargs or {}),
-            )
-            response.raise_for_status()
-            return AgentCard.model_validate(response.json())
-        except httpx.HTTPStatusError as e:
-            raise A2AClientHTTPError(e.response.status_code, str(e)) from e
-        except json.JSONDecodeError as e:
-            raise A2AClientJSONError(str(e)) from e
-        except httpx.RequestError as e:
-            raise A2AClientHTTPError(
-                503, f'Network communication error: {e}'
-            ) from e
-
-
-class A2AClient:
-    """A2A Client."""
+@dataclasses.dataclass
+class ClientConfig:
+    """Configuration class for the A2AClient Factory."""
+
+    streaming: bool = True
+    """Whether client supports streaming"""
+
+    polling: bool = False
+    """Whether client prefers to poll for updates from message:send. It is
+    the callers job to check if the response is completed and if not run a
+    polling loop."""
+
+    httpx_client: httpx.AsyncClient | None = None
+    """Http client to use to connect to agent."""
+
+    grpc_channel_factory: Callable[[str], Channel] | None = None
+    """Generates a grpc connection channel for a given url."""
+
+    supported_protocol_bindings: list[str] = dataclasses.field(
+        default_factory=list
+    )
+    """Ordered list of transports for connecting to agent
+       (in order of preference). Empty implies JSONRPC only.
+
+       This is a string type to allow custom
+       transports to exist in closed ecosystems.
+    """
+
+    use_client_preference: bool = False
+    """Whether to use client transport preferences over server preferences.
+       Recommended to use server preferences in most situations."""
+
+    accepted_output_modes: list[str] = dataclasses.field(default_factory=list)
+    """The set of accepted output modes for the client."""
+
+    push_notification_config: TaskPushNotificationConfig | None = None
+    """Push notification configuration to use for every request."""
+
+
+class ClientCallContext(BaseModel):
+    """A context passed with each client call, allowing for call-specific.
+
+    configuration and data passing. Such as authentication details or
+    request deadlines.
+    """
+
+    state: MutableMapping[str, Any] = Field(default_factory=dict)
+    timeout: float | None = None
+    service_parameters: ServiceParameters | None = None
+
+
+class Client(ABC):
+    """Abstract base class defining the interface for an A2A client.
+
+    This class provides a standard set of methods for interacting with an A2A
+    agent, regardless of the underlying transport protocol (e.g., gRPC, JSON-RPC).
+    It supports sending messages, managing tasks, and handling event streams.
+    """
 
     def __init__(
         self,
-        httpx_client: httpx.AsyncClient,
-        agent_card: AgentCard | None = None,
-        url: str | None = None,
+        interceptors: list[ClientCallInterceptor] | None = None,
     ):
-        if agent_card:
-            self.url = agent_card.url
-        elif url:
-            self.url = url
-        else:
-            raise ValueError('Must provide either agent_card or url')
-
-        self.httpx_client = httpx_client
-
-    @staticmethod
-    async def get_client_from_agent_card_url(
-        httpx_client: httpx.AsyncClient,
-        base_url: str,
-        agent_card_path: str = '/.well-known/agent.json',
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> 'A2AClient':
-        """Get a A2A client for provided agent card URL."""
-        agent_card: AgentCard = await A2ACardResolver(
-            httpx_client, base_url=base_url, agent_card_path=agent_card_path
-        ).get_agent_card(http_kwargs=http_kwargs)
-        return A2AClient(httpx_client=httpx_client, agent_card=agent_card)
+        """Initializes the client with interceptors.
+
+        Args:
+            interceptors: A list of interceptors to process requests and responses.
+        """
+        self._interceptors = interceptors or []
+
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager."""
+        return self
 
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager and closes the client."""
+        await self.close()
+
+    @abstractmethod
     async def send_message(
         self,
         request: SendMessageRequest,
         *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> SendMessageResponse:
-        if not request.id:
-            request.id = str(uuid4())
-
-        return SendMessageResponse(
-            **await self._send_request(
-                request.model_dump(mode='json', exclude_none=True),
-                http_kwargs,
-            )
-        )
-
-    async def send_message_streaming(
-        self,
-        request: SendStreamingMessageRequest,
-        *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> AsyncGenerator[SendStreamingMessageResponse, None]:
-        if not request.id:
-            request.id = str(uuid4())
-
-        # Default to no timeout for streaming, can be overridden by http_kwargs
-        http_kwargs_with_timeout: dict[str, Any] = {
-            'timeout': None,
-            **(http_kwargs or {}),
-        }
-
-        async with aconnect_sse(
-            self.httpx_client,
-            'POST',
-            self.url,
-            json=request.model_dump(mode='json', exclude_none=True),
-            **http_kwargs_with_timeout,
-        ) as event_source:
-            try:
-                async for sse in event_source.aiter_sse():
-                    yield SendStreamingMessageResponse(**json.loads(sse.data))
-            except SSEError as e:
-                raise A2AClientHTTPError(
-                    400,
-                    f'Invalid SSE response or protocol error: {e}',
-                ) from e
-            except json.JSONDecodeError as e:
-                raise A2AClientJSONError(str(e)) from e
-            except httpx.RequestError as e:
-                raise A2AClientHTTPError(
-                    503, f'Network communication error: {e}'
-                ) from e
-
-    async def _send_request(
-        self,
-        rpc_request_payload: dict[str, Any],
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Sends a non-streaming JSON-RPC request to the agent.
+        context: ClientCallContext | None = None,
+    ) -> AsyncIterator[StreamResponse]:
+        """Sends a message to the server.
 
-        Args:
-            rpc_request_payload: JSON RPC payload for sending the request
-            **kwargs: Additional keyword arguments to pass to the httpx client.
+        This will automatically use the streaming or non-streaming approach
+        as supported by the server and the client config. Client will
+        aggregate update events and return an iterator of `StreamResponse`.
         """
-        try:
-            response = await self.httpx_client.post(
-                self.url, json=rpc_request_payload, **(http_kwargs or {})
-            )
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPStatusError as e:
-            raise A2AClientHTTPError(e.response.status_code, str(e)) from e
-        except json.JSONDecodeError as e:
-            raise A2AClientJSONError(str(e)) from e
-        except httpx.RequestError as e:
-            raise A2AClientHTTPError(
-                503, f'Network communication error: {e}'
-            ) from e
+        return
+        yield
 
+    @abstractmethod
     async def get_task(
         self,
         request: GetTaskRequest,
         *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> GetTaskResponse:
-        if not request.id:
-            request.id = str(uuid4())
-
-        return GetTaskResponse(
-            **await self._send_request(
-                request.model_dump(mode='json', exclude_none=True),
-                http_kwargs,
-            )
-        )
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+
+    @abstractmethod
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
 
+    @abstractmethod
     async def cancel_task(
         self,
         request: CancelTaskRequest,
         *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> CancelTaskResponse:
-        if not request.id:
-            request.id = str(uuid4())
-
-        return CancelTaskResponse(
-            **await self._send_request(
-                request.model_dump(mode='json', exclude_none=True),
-                http_kwargs,
-            )
-        )
-
-    async def set_task_callback(
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+
+    @abstractmethod
+    async def create_task_push_notification_config(
         self,
-        request: SetTaskPushNotificationConfigRequest,
+        request: TaskPushNotificationConfig,
         *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> SetTaskPushNotificationConfigResponse:
-        if not request.id:
-            request.id = str(uuid4())
-
-        return SetTaskPushNotificationConfigResponse(
-            **await self._send_request(
-                request.model_dump(mode='json', exclude_none=True),
-                http_kwargs,
-            )
-        )
-
-    async def get_task_callback(
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def get_task_push_notification_config(
         self,
         request: GetTaskPushNotificationConfigRequest,
         *,
-        http_kwargs: dict[str, Any] | None = None,
-    ) -> GetTaskPushNotificationConfigResponse:
-        if not request.id:
-            request.id = str(uuid4())
-
-        return GetTaskPushNotificationConfigResponse(
-            **await self._send_request(
-                request.model_dump(mode='json', exclude_none=True),
-                http_kwargs,
-            )
-        )
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+
+    @abstractmethod
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncIterator[StreamResponse]:
+        """Resubscribes to a task's event stream."""
+        return
+        yield
+
+    @abstractmethod
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+        signature_verifier: Callable[[AgentCard], None] | None = None,
+    ) -> AgentCard:
+        """Retrieves the agent's card."""
+
+    async def add_interceptor(self, interceptor: ClientCallInterceptor) -> None:
+        """Attaches additional interceptors to the `Client`."""
+        self._interceptors.append(interceptor)
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Closes the client and releases any underlying resources."""
diff --git a/src/a2a/client/client_factory.py b/src/a2a/client/client_factory.py
new file mode 100644
index 000000000..db6266779
--- /dev/null
+++ b/src/a2a/client/client_factory.py
@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import logging
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from packaging.version import InvalidVersion, Version
+
+from a2a.client.base_client import BaseClient
+from a2a.client.card_resolver import A2ACardResolver
+from a2a.client.client import Client, ClientConfig
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.jsonrpc import JsonRpcTransport
+from a2a.client.transports.rest import RestTransport
+from a2a.client.transports.tenant_decorator import TenantTransportDecorator
+from a2a.compat.v0_3.versions import is_legacy_version
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+)
+from a2a.utils.constants import (
+    PROTOCOL_VERSION_0_3,
+    PROTOCOL_VERSION_1_0,
+    PROTOCOL_VERSION_CURRENT,
+    VERSION_HEADER,
+    TransportProtocol,
+)
+
+
+if TYPE_CHECKING:
+    from a2a.client.interceptors import ClientCallInterceptor
+
+
+try:
+    from a2a.client.transports.grpc import GrpcTransport
+except ImportError:
+    GrpcTransport = None  # type: ignore # pyright: ignore
+
+
+try:
+    from a2a.compat.v0_3.grpc_transport import CompatGrpcTransport
+except ImportError:
+    CompatGrpcTransport = None  # type: ignore # pyright: ignore
+
+logger = logging.getLogger(__name__)
+
+
+TransportProducer = Callable[
+    [AgentCard, str, ClientConfig],
+    ClientTransport,
+]
+
+
+def major_minor(version: str) -> tuple[int, int]:
+    """Returns the `Major.Minor` release of a protocol version."""
+    v = Version(version)
+    return (v.major, v.minor)
+
+
+class ClientFactory:
+    """Factory for creating clients that communicate with A2A agents.
+
+    The factory is configured with a `ClientConfig` and optionally custom
+    transport producers registered via `register`. Example usage:
+
+        factory = ClientFactory(config)
+        # Optionally register custom transport implementations
+        factory.register('my_custom_transport', custom_transport_producer)
+        # Create a client from an AgentCard
+        client = factory.create(card, interceptors)
+        # Or resolve an AgentCard from a URL and create a client
+        client = await factory.create_from_url('https://example.com')
+
+    The client can be used consistently regardless of the transport. This
+    aligns the client configuration with the server's capabilities.
+
+    Each created client gets its own `httpx.AsyncClient` and closes it on
+    `close()`, unless `ClientConfig.httpx_client` is set.
+    """
+
+    def __init__(
+        self,
+        config: ClientConfig | None = None,
+    ):
+        config = config or ClientConfig()
+        if config.httpx_client:
+            config.httpx_client.headers.setdefault(
+                VERSION_HEADER, PROTOCOL_VERSION_CURRENT
+            )
+
+        self._config = config
+        self._registry: dict[str, TransportProducer] = {}
+        self._register_defaults(config.supported_protocol_bindings)
+
+    def _resolve_http_client(self) -> tuple[httpx.AsyncClient, bool]:
+        """Returns an HTTP client and whether it is shared across clients."""
+        if self._config.httpx_client:
+            return self._config.httpx_client, True
+        httpx_client = httpx.AsyncClient()
+        httpx_client.headers.setdefault(
+            VERSION_HEADER, PROTOCOL_VERSION_CURRENT
+        )
+        return httpx_client, False
+
+    def _register_defaults(self, supported: list[str]) -> None:
+        # Empty support list implies JSON-RPC only.
+
+        if TransportProtocol.JSONRPC in supported or not supported:
+
+            def jsonrpc_transport_producer(
+                card: AgentCard,
+                url: str,
+                config: ClientConfig,
+            ) -> ClientTransport:
+                interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[TransportProtocol.JSONRPC],
+                    url=url,
+                )
+                version = (
+                    interface.protocol_version
+                    if interface
+                    else PROTOCOL_VERSION_CURRENT
+                )
+
+                httpx_client, is_shared_httpx = self._resolve_http_client()
+
+                if is_legacy_version(version):
+                    from a2a.compat.v0_3.jsonrpc_transport import (  # noqa: PLC0415
+                        CompatJsonRpcTransport,
+                    )
+
+                    return CompatJsonRpcTransport(
+                        httpx_client,
+                        card,
+                        url,
+                        is_shared_httpx=is_shared_httpx,
+                    )
+
+                return JsonRpcTransport(
+                    httpx_client,
+                    card,
+                    url,
+                    is_shared_httpx=is_shared_httpx,
+                )
+
+            self.register(
+                TransportProtocol.JSONRPC,
+                jsonrpc_transport_producer,
+            )
+        if TransportProtocol.HTTP_JSON in supported:
+
+            def rest_transport_producer(
+                card: AgentCard,
+                url: str,
+                config: ClientConfig,
+            ) -> ClientTransport:
+                interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[TransportProtocol.HTTP_JSON],
+                    url=url,
+                )
+                version = (
+                    interface.protocol_version
+                    if interface
+                    else PROTOCOL_VERSION_CURRENT
+                )
+
+                httpx_client, is_shared_httpx = self._resolve_http_client()
+
+                if is_legacy_version(version):
+                    from a2a.compat.v0_3.rest_transport import (  # noqa: PLC0415
+                        CompatRestTransport,
+                    )
+
+                    return CompatRestTransport(
+                        httpx_client,
+                        card,
+                        url,
+                        is_shared_httpx=is_shared_httpx,
+                    )
+
+                return RestTransport(
+                    httpx_client,
+                    card,
+                    url,
+                    is_shared_httpx=is_shared_httpx,
+                )
+
+            self.register(
+                TransportProtocol.HTTP_JSON,
+                rest_transport_producer,
+            )
+        if TransportProtocol.GRPC in supported:
+            if GrpcTransport is None:
+                raise ImportError(
+                    'To use GrpcClient, its dependencies must be installed. '
+                    'You can install them with \'pip install "a2a-sdk[grpc]"\''
+                )
+
+            _grpc_transport = GrpcTransport
+
+            def grpc_transport_producer(
+                card: AgentCard,
+                url: str,
+                config: ClientConfig,
+            ) -> ClientTransport:
+                # The interface has already been selected and passed as `url`.
+                # We determine its version to use the appropriate transport implementation.
+                interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[TransportProtocol.GRPC],
+                    url=url,
+                )
+                version = (
+                    interface.protocol_version
+                    if interface
+                    else PROTOCOL_VERSION_CURRENT
+                )
+
+                if (
+                    is_legacy_version(version)
+                    and CompatGrpcTransport is not None
+                ):
+                    return CompatGrpcTransport.create(card, url, config)
+
+                return _grpc_transport.create(card, url, config)
+
+            self.register(
+                TransportProtocol.GRPC,
+                grpc_transport_producer,
+            )
+
+    @staticmethod
+    def _find_best_interface(
+        interfaces: list[AgentInterface],
+        protocol_bindings: list[str] | None = None,
+        url: str | None = None,
+    ) -> AgentInterface | None:
+        """Finds the best interface based on protocol version priorities."""
+        candidates = [
+            i
+            for i in interfaces
+            if (
+                protocol_bindings is None
+                or i.protocol_binding in protocol_bindings
+            )
+            and (url is None or i.url == url)
+        ]
+
+        if not candidates:
+            return None
+
+        # Prefer interface with version 1.0. Patch versions must not affect
+        # negotiation, so '1.0.0' counts as '1.0'.
+        v1_0 = major_minor(PROTOCOL_VERSION_1_0)
+        v0_3 = major_minor(PROTOCOL_VERSION_0_3)
+
+        best_gt_1_0 = None
+        best_ge_0_3 = None
+        best_no_version = None
+
+        for i in candidates:
+            if not i.protocol_version:
+                if best_no_version is None:
+                    best_no_version = i
+                continue
+
+            try:
+                v = major_minor(i.protocol_version)
+                if v == v1_0:
+                    return i
+                if best_gt_1_0 is None and v > v1_0:
+                    best_gt_1_0 = i
+                if best_ge_0_3 is None and v >= v0_3:
+                    best_ge_0_3 = i
+            except InvalidVersion:
+                pass
+
+        return best_gt_1_0 or best_ge_0_3 or best_no_version
+
+    async def create_from_url(
+        self,
+        url: str,
+        interceptors: list[ClientCallInterceptor] | None = None,
+        relative_card_path: str | None = None,
+        resolver_http_kwargs: dict[str, Any] | None = None,
+        signature_verifier: Callable[[AgentCard], None] | None = None,
+    ) -> Client:
+        """Create a `Client` by resolving an `AgentCard` from a URL.
+
+        Resolves the agent card from the given URL, then creates a client
+        via `create`. The card is fetched with `ClientConfig.httpx_client`
+        when one is set, otherwise with a temporary client.
+
+        If the agent card is already available, use `create` directly
+        instead.
+
+        Args:
+          url: The base URL of the agent. The agent card will be fetched
+            from `<url>/.well-known/agent-card.json` by default.
+          interceptors: A list of interceptors to use for each request.
+            These are used for things like attaching credentials or http
+            headers to all outbound requests.
+          relative_card_path: The relative path when resolving the agent
+            card. See `A2ACardResolver.get_agent_card` for details.
+          resolver_http_kwargs: Dictionary of arguments to provide to the
+            httpx client when resolving the agent card.
+          signature_verifier: A callable used to verify the agent card's
+            signatures.
+
+        Returns:
+          A `Client` object.
+        """
+        httpx_client, is_shared_httpx = self._resolve_http_client()
+        try:
+            resolver = A2ACardResolver(httpx_client, url)
+            card = await resolver.get_agent_card(
+                relative_card_path=relative_card_path,
+                http_kwargs=resolver_http_kwargs,
+                signature_verifier=signature_verifier,
+            )
+        finally:
+            if not is_shared_httpx:
+                await httpx_client.aclose()
+        return self.create(card, interceptors)
+
+    def register(self, label: str, generator: TransportProducer) -> None:
+        """Register a new transport producer for a given transport label."""
+        self._registry[label] = generator
+
+    def create(
+        self,
+        card: AgentCard,
+        interceptors: list[ClientCallInterceptor] | None = None,
+    ) -> Client:
+        """Create a new `Client` for the provided `AgentCard`.
+
+        Args:
+          card: An `AgentCard` defining the characteristics of the agent.
+          interceptors: A list of interceptors to use for each request. These
+            are used for things like attaching credentials or http headers
+            to all outbound requests.
+
+        Returns:
+          A `Client` object.
+
+        Raises:
+          If there is no valid matching of the client configuration with the
+          server configuration, a `ValueError` is raised.
+        """
+        client_set = self._config.supported_protocol_bindings or [
+            TransportProtocol.JSONRPC
+        ]
+        transport_protocol = None
+        selected_interface = None
+        if self._config.use_client_preference:
+            for protocol_binding in client_set:
+                selected_interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[protocol_binding],
+                )
+                if selected_interface:
+                    transport_protocol = protocol_binding
+                    break
+        else:
+            for supported_interface in card.supported_interfaces:
+                if supported_interface.protocol_binding in client_set:
+                    transport_protocol = supported_interface.protocol_binding
+                    selected_interface = ClientFactory._find_best_interface(
+                        list(card.supported_interfaces),
+                        protocol_bindings=[transport_protocol],
+                    )
+                    break
+        if not transport_protocol or not selected_interface:
+            raise ValueError('no compatible transports found.')
+        if transport_protocol not in self._registry:
+            raise ValueError(f'no client available for {transport_protocol}')
+
+        transport = self._registry[transport_protocol](
+            card, selected_interface.url, self._config
+        )
+
+        if selected_interface.tenant:
+            transport = TenantTransportDecorator(
+                transport, selected_interface.tenant
+            )
+
+        return BaseClient(
+            card,
+            self._config,
+            transport,
+            interceptors or [],
+        )
+
+
+async def create_client(  # noqa: PLR0913
+    agent: str | AgentCard,
+    client_config: ClientConfig | None = None,
+    interceptors: list[ClientCallInterceptor] | None = None,
+    relative_card_path: str | None = None,
+    resolver_http_kwargs: dict[str, Any] | None = None,
+    signature_verifier: Callable[[AgentCard], None] | None = None,
+) -> Client:
+    """Create a `Client` for an agent from a URL or `AgentCard`.
+
+    Convenience function that constructs a `ClientFactory` internally.
+    For reusing a factory across multiple agents or registering custom
+    transports, use `ClientFactory` directly instead.
+
+    Args:
+      agent: The base URL of the agent, or an `AgentCard` to use
+        directly.
+      client_config: Optional `ClientConfig`. A default config is
+        created if not provided.
+      interceptors: A list of interceptors to use for each request.
+      relative_card_path: The relative path when resolving the agent
+        card. Only used when `agent` is a URL.
+      resolver_http_kwargs: Dictionary of arguments to provide to the
+        httpx client when resolving the agent card.
+      signature_verifier: A callable used to verify the agent card's
+        signatures.
+
+    Returns:
+      A `Client` object.
+    """
+    factory = ClientFactory(client_config)
+    if isinstance(agent, str):
+        return await factory.create_from_url(
+            agent,
+            interceptors=interceptors,
+            relative_card_path=relative_card_path,
+            resolver_http_kwargs=resolver_http_kwargs,
+            signature_verifier=signature_verifier,
+        )
+    return factory.create(agent, interceptors)
+
+
+def minimal_agent_card(
+    url: str, transports: list[str] | None = None
+) -> AgentCard:
+    """Generates a minimal card to simplify bootstrapping client creation.
+
+    This minimal card is not viable itself to interact with the remote agent.
+    Instead this is a shorthand way to take a known url and transport option
+    and interact with the get card endpoint of the agent server to get the
+    correct agent card. This pattern is necessary for gRPC based card access
+    as typically these servers won't expose a well known path card.
+    """
+    if transports is None:
+        transports = []
+    return AgentCard(
+        supported_interfaces=[
+            AgentInterface(protocol_binding=t, url=url) for t in transports
+        ],
+        capabilities=AgentCapabilities(extended_agent_card=True),
+        default_input_modes=[],
+        default_output_modes=[],
+        description='',
+        skills=[],
+        version='',
+        name='',
+    )
diff --git a/src/a2a/client/errors.py b/src/a2a/client/errors.py
index b5e8d4751..853ff597f 100644
--- a/src/a2a/client/errors.py
+++ b/src/a2a/client/errors.py
@@ -1,19 +1,27 @@
-class A2AClientError(Exception):
-    """Base exception for client A2A Client errors."""
+"""Custom exceptions for the A2A client."""
 
+from a2a.utils.errors import A2AError
 
-class A2AClientHTTPError(A2AClientError):
-    """Client exception for HTTP errors."""
 
-    def __init__(self, status_code: int, message: str):
+class A2AClientError(A2AError):
+    """Base exception for A2A Client errors."""
+
+
+class AgentCardResolutionError(A2AClientError):
+    """Exception raised when an agent card cannot be resolved."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
         self.status_code = status_code
-        self.message = message
-        super().__init__(f'HTTP Error {status_code}: {message}')
 
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation exposing the status code."""
+        return (
+            f'{self.__class__.__name__}('
+            f'status_code={self.status_code!r}, '
+            f'message={self.message!r})'
+        )
 
-class A2AClientJSONError(A2AClientError):
-    """Client exception for JSON errors."""
 
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(f'JSON Error: {message}')
+class A2AClientTimeoutError(A2AClientError):
+    """Exception for timeout errors during a request."""
diff --git a/src/a2a/client/helpers.py b/src/a2a/client/helpers.py
deleted file mode 100644
index ab728b731..000000000
--- a/src/a2a/client/helpers.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from uuid import uuid4
-
-from a2a.types import Message, Part, Role, TextPart
-
-
-def create_text_message_object(
-    role: Role = Role.user, content: str = ''
-) -> Message:
-    """Create a Message object for the given role and content."""
-    return Message(
-        role=role, parts=[Part(TextPart(text=content))], messageId=str(uuid4())
-    )
diff --git a/src/a2a/client/interceptors.py b/src/a2a/client/interceptors.py
new file mode 100644
index 000000000..9903708f3
--- /dev/null
+++ b/src/a2a/client/interceptors.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from a2a.client.client import ClientCallContext
+
+from a2a.types.a2a_pb2 import (  # noqa: TC001
+    AgentCard,
+)
+
+
+@dataclass
+class BeforeArgs:
+    """Arguments passed to the interceptor before a method call."""
+
+    input: Any
+    method: str
+    agent_card: AgentCard
+    context: ClientCallContext | None = None
+    early_return: Any | None = None
+
+
+@dataclass
+class AfterArgs:
+    """Arguments passed to the interceptor after a method call completes."""
+
+    result: Any
+    method: str
+    agent_card: AgentCard
+    context: ClientCallContext | None = None
+    early_return: bool = False
+
+
+class ClientCallInterceptor(ABC):
+    """An abstract base class for client-side call interceptors.
+
+    Interceptors can inspect and modify requests before they are sent,
+    which is ideal for concerns like authentication, logging, or tracing.
+    """
+
+    @abstractmethod
+    async def before(self, args: BeforeArgs) -> None:
+        """Invoked before transport method."""
+
+    @abstractmethod
+    async def after(self, args: AfterArgs) -> None:
+        """Invoked after transport method."""
diff --git a/src/a2a/client/optionals.py b/src/a2a/client/optionals.py
new file mode 100644
index 000000000..7576cf0db
--- /dev/null
+++ b/src/a2a/client/optionals.py
@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+
+# Attempt to import the optional module
+try:
+    from grpc.aio import Channel  # type: ignore[reportMissingModuleSource]
+except ImportError:
+    # If grpc.aio is not available, define a stub type for type checking.
+    # This stub type will only be used by type checkers.
+    if TYPE_CHECKING:
+
+        class Channel:  # type: ignore[no-redef]
+            """Stub class for type hinting when grpc.aio is not available."""
+
+            async def close(self, grace: float | None = None) -> None:
+                """Stub for Channel.close."""
+
+    else:
+        Channel = None  # At runtime, pd will be None if the import failed.
diff --git a/src/a2a/client/service_parameters.py b/src/a2a/client/service_parameters.py
new file mode 100644
index 000000000..39fe79ce1
--- /dev/null
+++ b/src/a2a/client/service_parameters.py
@@ -0,0 +1,64 @@
+from collections.abc import Callable
+from typing import TypeAlias
+
+from a2a.extensions.common import (
+    HTTP_EXTENSION_HEADER,
+    get_requested_extensions,
+)
+
+
+ServiceParameters: TypeAlias = dict[str, str]
+ServiceParametersUpdate: TypeAlias = Callable[[ServiceParameters], None]
+
+
+class ServiceParametersFactory:
+    """Factory for creating ServiceParameters."""
+
+    @staticmethod
+    def create(updates: list[ServiceParametersUpdate]) -> ServiceParameters:
+        """Create ServiceParameters from a list of updates.
+
+        Args:
+            updates: List of update functions to apply.
+
+        Returns:
+            The created ServiceParameters dictionary.
+        """
+        return ServiceParametersFactory.create_from(None, updates)
+
+    @staticmethod
+    def create_from(
+        service_parameters: ServiceParameters | None,
+        updates: list[ServiceParametersUpdate],
+    ) -> ServiceParameters:
+        """Create new ServiceParameters from existing ones and apply updates.
+
+        Args:
+            service_parameters: Optional existing ServiceParameters to start from.
+            updates: List of update functions to apply.
+
+        Returns:
+            New ServiceParameters dictionary.
+        """
+        result = service_parameters.copy() if service_parameters else {}
+        for update in updates:
+            update(result)
+        return result
+
+
+def with_a2a_extensions(extensions: list[str]) -> ServiceParametersUpdate:
+    """Create a ServiceParametersUpdate that merges A2A extension URIs.
+
+    Unions the supplied URIs with any already present in the A2A-Extensions
+    parameter, deduplicating and emitting them in sorted order. Repeated
+    calls accumulate rather than overwrite.
+    """
+
+    def update(parameters: ServiceParameters) -> None:
+        if not extensions:
+            return
+        existing = parameters.get(HTTP_EXTENSION_HEADER, '')
+        merged = sorted(get_requested_extensions([existing, *extensions]))
+        parameters[HTTP_EXTENSION_HEADER] = ','.join(merged)
+
+    return update
diff --git a/src/a2a/client/transports/__init__.py b/src/a2a/client/transports/__init__.py
new file mode 100644
index 000000000..af7c60f62
--- /dev/null
+++ b/src/a2a/client/transports/__init__.py
@@ -0,0 +1,19 @@
+"""A2A Client Transports."""
+
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.jsonrpc import JsonRpcTransport
+from a2a.client.transports.rest import RestTransport
+
+
+try:
+    from a2a.client.transports.grpc import GrpcTransport
+except ImportError:
+    GrpcTransport = None  # type: ignore
+
+
+__all__ = [
+    'ClientTransport',
+    'GrpcTransport',
+    'JsonRpcTransport',
+    'RestTransport',
+]
diff --git a/src/a2a/client/transports/base.py b/src/a2a/client/transports/base.py
new file mode 100644
index 000000000..e46aae25e
--- /dev/null
+++ b/src/a2a/client/transports/base.py
@@ -0,0 +1,149 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from types import TracebackType
+
+from typing_extensions import Self
+
+from a2a.client.client import ClientCallContext
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+
+
+class ClientTransport(ABC):
+    """Abstract base class for a client transport."""
+
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager, returning the transport itself."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager, ensuring close() is called."""
+        await self.close()
+
+    @abstractmethod
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+
+    @abstractmethod
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        return
+        yield
+
+    @abstractmethod
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+
+    @abstractmethod
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+
+    @abstractmethod
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+
+    @abstractmethod
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+
+    @abstractmethod
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+
+    @abstractmethod
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        return
+        yield
+
+    @abstractmethod
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the Extended AgentCard."""
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Closes the transport."""
diff --git a/src/a2a/client/transports/grpc.py b/src/a2a/client/transports/grpc.py
new file mode 100644
index 000000000..9b52af35d
--- /dev/null
+++ b/src/a2a/client/transports/grpc.py
@@ -0,0 +1,346 @@
+import logging
+
+from collections.abc import AsyncGenerator, Callable
+from functools import wraps
+from typing import Any, NoReturn, cast
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError, A2AClientTimeoutError
+
+
+try:
+    import grpc  # type: ignore[reportMissingModuleSource]
+except ImportError as e:
+    raise ImportError(
+        'A2AGrpcClient requires grpcio and grpcio-tools to be installed. '
+        'Install with: '
+        "'pip install a2a-sdk[grpc]'"
+    ) from e
+
+
+from google.rpc import (  # type: ignore[reportMissingModuleSource]
+    error_details_pb2,
+)
+
+from a2a.client.client import ClientConfig
+from a2a.client.optionals import Channel
+from a2a.client.transports.base import ClientTransport
+from a2a.types import a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.constants import PROTOCOL_VERSION_CURRENT, VERSION_HEADER
+from a2a.utils.errors import A2A_REASON_TO_ERROR, A2AError
+from a2a.utils.grpc_status import status_from_call
+from a2a.utils.proto_utils import bad_request_to_validation_errors
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+
+def _map_grpc_error(e: grpc.aio.AioRpcError) -> NoReturn:
+    if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
+        raise A2AClientTimeoutError('Client Request timed out') from e
+
+    status = status_from_call(cast('grpc.Call', e))
+    data = None
+
+    if status is not None:
+        exception_cls: type[A2AError] | None = None
+        for detail in status.details:
+            # `.DESCRIPTOR` is typed as a py/C union; `.Is` wants a Descriptor.
+            if detail.Is(error_details_pb2.ErrorInfo.DESCRIPTOR):  # ty: ignore[invalid-argument-type]
+                error_info = error_details_pb2.ErrorInfo()
+                detail.Unpack(error_info)
+                if error_info.domain == 'a2a-protocol.org':
+                    exception_cls = A2A_REASON_TO_ERROR.get(error_info.reason)
+            elif detail.Is(error_details_pb2.BadRequest.DESCRIPTOR):  # ty: ignore[invalid-argument-type]
+                bad_request = error_details_pb2.BadRequest()
+                detail.Unpack(bad_request)
+                data = {'errors': bad_request_to_validation_errors(bad_request)}
+
+        if exception_cls:
+            raise exception_cls(status.message, data=data) from e
+
+    raise A2AClientError(f'gRPC Error {e.code().name}: {e.details()}') from e
+
+
+def _handle_grpc_exception(func: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return await func(*args, **kwargs)
+        except grpc.aio.AioRpcError as e:
+            _map_grpc_error(e)
+
+    return wrapper
+
+
+def _handle_grpc_stream_exception(
+    func: Callable[..., Any],
+) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            async for item in func(*args, **kwargs):
+                yield item
+        except grpc.aio.AioRpcError as e:
+            _map_grpc_error(e)
+
+    return wrapper
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class GrpcTransport(ClientTransport):
+    """A gRPC transport for the A2A client."""
+
+    def __init__(
+        self,
+        channel: Channel,
+        agent_card: AgentCard | None,
+    ):
+        """Initializes the GrpcTransport."""
+        self.agent_card = agent_card
+        self.channel = channel
+        self.stub = a2a_pb2_grpc.A2AServiceStub(channel)
+
+    @classmethod
+    def create(
+        cls,
+        card: AgentCard,
+        url: str,
+        config: ClientConfig,
+    ) -> 'GrpcTransport':
+        """Creates a gRPC transport for the A2A client."""
+        if config.grpc_channel_factory is None:
+            raise ValueError('grpc_channel_factory is required when using gRPC')
+        return cls(config.grpc_channel_factory(url), card)
+
+    @_handle_grpc_exception
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+        return await self._call_grpc(
+            self.stub.SendMessage,
+            request,
+            context,
+        )
+
+    @_handle_grpc_stream_exception
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        async for response in self._call_grpc_stream(
+            self.stub.SendStreamingMessage,
+            request,
+            context,
+        ):
+            yield response
+
+    @_handle_grpc_stream_exception
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        async for response in self._call_grpc_stream(
+            self.stub.SubscribeToTask,
+            request,
+            context,
+        ):
+            yield response
+
+    @_handle_grpc_exception
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        return await self._call_grpc(
+            self.stub.GetTask,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        return await self._call_grpc(
+            self.stub.ListTasks,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        return await self._call_grpc(
+            self.stub.CancelTask,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        return await self._call_grpc(
+            self.stub.CreateTaskPushNotificationConfig,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        return await self._call_grpc(
+            self.stub.GetTaskPushNotificationConfig,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        return await self._call_grpc(
+            self.stub.ListTaskPushNotificationConfigs,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        await self._call_grpc(
+            self.stub.DeleteTaskPushNotificationConfig,
+            request,
+            context,
+        )
+
+    @_handle_grpc_exception
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the agent's card."""
+        card = self.agent_card
+        if card and not card.capabilities.extended_agent_card:
+            return card
+
+        return await self._call_grpc(
+            self.stub.GetExtendedAgentCard,
+            request,
+            context,
+        )
+
+    async def close(self) -> None:
+        """Closes the gRPC channel."""
+        await self.channel.close()
+
+    def _get_grpc_metadata(
+        self, context: ClientCallContext | None
+    ) -> list[tuple[str, str]]:
+        metadata: list[tuple[str, str]] = [
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT)
+        ]
+        if context and context.service_parameters:
+            for key, value in context.service_parameters.items():
+                metadata.append((key.lower(), value))
+        return metadata
+
+    def _get_grpc_timeout(
+        self, context: ClientCallContext | None
+    ) -> float | None:
+        return context.timeout if context else None
+
+    async def _call_grpc(
+        self,
+        method: Callable[..., Any],
+        request: Any,
+        context: ClientCallContext | None,
+        **kwargs: Any,
+    ) -> Any:
+        return await method(
+            request,
+            metadata=self._get_grpc_metadata(context),
+            timeout=self._get_grpc_timeout(context),
+            **kwargs,
+        )
+
+    async def _call_grpc_stream(
+        self,
+        method: Callable[..., Any],
+        request: Any,
+        context: ClientCallContext | None,
+        **kwargs: Any,
+    ) -> AsyncGenerator[StreamResponse]:
+        stream = method(
+            request,
+            metadata=self._get_grpc_metadata(context),
+            timeout=self._get_grpc_timeout(context),
+            **kwargs,
+        )
+        while True:
+            response = await stream.read()
+            if response == grpc.aio.EOF:  # pyright: ignore[reportAttributeAccessIssue]
+                break
+            yield response
diff --git a/src/a2a/client/transports/http_helpers.py b/src/a2a/client/transports/http_helpers.py
new file mode 100644
index 000000000..036e0fe3b
--- /dev/null
+++ b/src/a2a/client/transports/http_helpers.py
@@ -0,0 +1,232 @@
+import json
+import re
+
+from collections.abc import AsyncGenerator, Callable, Iterator
+from contextlib import contextmanager
+from typing import Any, NoReturn
+
+import httpx
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError, A2AClientTimeoutError
+
+
+def _default_sse_error_handler(sse_data: str) -> NoReturn:
+    raise A2AClientError(f'SSE stream error event received: {sse_data}')
+
+
+@contextmanager
+def handle_http_exceptions(
+    status_error_handler: Callable[[httpx.HTTPStatusError], NoReturn]
+    | None = None,
+) -> Iterator[None]:
+    """Handles common HTTP exceptions for REST and JSON-RPC transports.
+
+    Args:
+        status_error_handler: Optional handler for `httpx.HTTPStatusError`.
+            If provided, this handler should raise an appropriate domain-specific exception.
+            If not provided, a default `A2AClientError` will be raised.
+    """
+    try:
+        yield
+    except httpx.TimeoutException as e:
+        raise A2AClientTimeoutError('Client Request timed out') from e
+    except httpx.HTTPStatusError as e:
+        if status_error_handler:
+            status_error_handler(e)
+        raise A2AClientError(f'HTTP Error {e.response.status_code}: {e}') from e
+    except httpx.RequestError as e:
+        raise A2AClientError(f'Network communication error: {e}') from e
+    except json.JSONDecodeError as e:
+        raise A2AClientError(f'JSON Decode Error: {e}') from e
+
+
+def get_http_args(context: ClientCallContext | None) -> dict[str, Any]:
+    """Extracts HTTP arguments from the client call context."""
+    http_kwargs: dict[str, Any] = {}
+    if context and context.service_parameters:
+        http_kwargs['headers'] = context.service_parameters.copy()
+    if context and context.timeout is not None:
+        http_kwargs['timeout'] = context.timeout
+    return http_kwargs
+
+
+async def send_http_request(
+    httpx_client: httpx.AsyncClient,
+    request: httpx.Request,
+    status_error_handler: Callable[[httpx.HTTPStatusError], NoReturn]
+    | None = None,
+) -> dict[str, Any]:
+    """Sends an HTTP request and parses the JSON response, handling common exceptions."""
+    if httpx_client.is_closed:
+        raise A2AClientError('HTTP client is closed')
+    with handle_http_exceptions(status_error_handler):
+        response = await httpx_client.send(request)
+        response.raise_for_status()
+        return response.json()
+
+
+_SSE_LINE_END = re.compile(r'\r\n|\r|\n')
+
+
+async def _aiter_sse_lines(
+    response: httpx.Response,
+) -> AsyncGenerator[str, None]:
+    """Yields lines ended only by CRLF, LF or CR, unlike `aiter_lines()`.
+
+    The unfinished line is kept as a list of pieces and joined once, and
+    only the new chunk is scanned, so a long `data:` line that spans many
+    chunks costs linear rather than quadratic time.
+    """
+    pieces: list[str] = []
+    held_cr = False
+    async for chunk in response.aiter_text():
+        text = '\r' + chunk if held_cr else chunk
+        # Hold a trailing CR back: the next chunk may start with its LF.
+        held_cr = text.endswith('\r')
+        *lines, rest = _SSE_LINE_END.split(text[:-1] if held_cr else text)
+        if lines:
+            lines[0] = ''.join(pieces) + lines[0]
+            pieces = []
+            for line in lines:
+                yield line
+        if rest:
+            pieces.append(rest)
+    tail = ''.join(pieces)
+    # A held CR at end of stream still ends a line, even an empty one. That
+    # blank line is what dispatches the last event, so yield it too.
+    if held_cr or tail:
+        yield tail
+
+
+async def parse_sse_stream(
+    response: httpx.Response,
+) -> AsyncGenerator[tuple[str, str], None]:
+    """Yields (event_name, data) from a streaming httpx.Response.
+
+    Conforms to the W3C Server-Sent Events specification.
+    """
+    event_name = 'message'
+    payload_chunks: list[str] = []
+
+    async for raw_line in _aiter_sse_lines(response):
+        # Empty line denotes the completion of the current event block
+        if not raw_line:
+            if payload_chunks:
+                yield event_name, '\n'.join(payload_chunks)
+            event_name = 'message'
+            payload_chunks = []
+            continue
+
+        # Ignore comment lines
+        if raw_line.startswith(':'):
+            continue
+
+        # Split key and value by first colon
+        parts = raw_line.split(':', 1)
+        key = parts[0]
+        val = parts[1] if len(parts) > 1 else ''
+
+        # Strip a single optional leading space
+        if val.startswith(' '):
+            val = val[1:]
+
+        if key == 'event':
+            event_name = val
+        elif key == 'data':
+            payload_chunks.append(val)
+
+
+async def send_http_stream_request(
+    httpx_client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    status_error_handler: Callable[[httpx.HTTPStatusError], NoReturn]
+    | None = None,
+    sse_error_handler: Callable[[str], NoReturn] = _default_sse_error_handler,
+    **kwargs: Any,
+) -> AsyncGenerator[str]:
+    """Sends a streaming HTTP request, yielding SSE data strings and handling exceptions.
+
+    Args:
+        httpx_client: The async HTTP client.
+        method: The HTTP method (e.g. 'POST', 'GET').
+        url: The URL to send the request to.
+        status_error_handler: Handler for HTTP status errors. Should raise an
+            appropriate domain-specific exception.
+        sse_error_handler: Handler for SSE error events. Called with the
+            raw SSE data string when an ``event: error`` SSE event is received.
+            Should raise an appropriate domain-specific exception.
+        **kwargs: Additional keyword arguments forwarded to ``aconnect_sse``.
+    """
+    if httpx_client.is_closed:
+        raise A2AClientError('HTTP client is closed')
+    with handle_http_exceptions(status_error_handler):
+        async with _SSEEventSource(
+            httpx_client, method, url, **kwargs
+        ) as response:
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                # Read upfront streaming error content immediately, otherwise lower-level handlers
+                # (e.g. response.json()) crash with 'ResponseNotRead' Access errors.
+                await response.aread()
+                raise e
+
+            # If the response is not a stream, read it standardly (e.g., upfront JSON-RPC error payload)
+            if 'text/event-stream' not in response.headers.get(
+                'content-type', ''
+            ):
+                content = await response.aread()
+                yield content.decode('utf-8')
+                return
+
+            async for event_name, data in parse_sse_stream(response):
+                if not data:
+                    continue
+                if event_name == 'error':
+                    sse_error_handler(data)
+                yield data
+
+
+class _SSEEventSource:
+    """Class-based context manager for managing streaming HTTP connections.
+
+    Using a class with `__aenter__` and `__aexit__` instead of an
+    `@asynccontextmanager` decorated function prevents event loop finalization
+    crashes (specifically `RuntimeError: GeneratorExit thrown into an active
+    generator`).
+
+    This error occurs when an outer async generator (e.g., streaming reader)
+    is abandoned early, causing the Python event loop to concurrently throw
+    GeneratorExit into the nested context manager's suspended generator.
+    Coroutine-based context managers are not async generators and avoid this
+    collision (see https://bugs.python.org/issue38559).
+    """
+
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        method: str,
+        url: str,
+        **kwargs: Any,
+    ) -> None:
+        headers: dict[str, str] = dict(kwargs.pop('headers', None) or {})
+        present = {key.lower() for key in headers}
+        if 'accept' not in present:
+            headers['Accept'] = 'text/event-stream'
+        if 'cache-control' not in present:
+            headers['Cache-Control'] = 'no-store'
+        self._request = client.build_request(
+            method, url, headers=headers, **kwargs
+        )
+        self._client = client
+        self._response: httpx.Response | None = None
+
+    async def __aenter__(self) -> httpx.Response:
+        self._response = await self._client.send(self._request, stream=True)
+        return self._response
+
+    async def __aexit__(self, *args: object) -> None:
+        if self._response is not None:
+            await self._response.aclose()
diff --git a/src/a2a/client/transports/jsonrpc.py b/src/a2a/client/transports/jsonrpc.py
new file mode 100644
index 000000000..8519b5c75
--- /dev/null
+++ b/src/a2a/client/transports/jsonrpc.py
@@ -0,0 +1,399 @@
+import json
+import logging
+
+from collections.abc import AsyncGenerator
+from typing import Any, NoReturn
+from uuid import uuid4
+
+import httpx
+
+from google.protobuf import json_format
+from jsonrpc.jsonrpc2 import JSONRPC20Request
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.http_helpers import (
+    get_http_args,
+    send_http_request,
+    send_http_stream_request,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP
+from a2a.utils.proto_utils import parse_lenient
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+_JSON_RPC_ERROR_CODE_TO_A2A_ERROR = {
+    code: error_type for error_type, code in JSON_RPC_ERROR_CODE_MAP.items()
+}
+_ERROR_INFO_TYPE = 'type.googleapis.com/google.rpc.ErrorInfo'
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class JsonRpcTransport(ClientTransport):
+    """A JSON-RPC transport for the A2A client."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        agent_card: AgentCard,
+        url: str,
+        is_shared_httpx: bool = False,
+    ):
+        """Initializes the JsonRpcTransport."""
+        self.url = url
+        self.httpx_client = httpx_client
+        self.agent_card = agent_card
+        self.is_shared_httpx = is_shared_httpx
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+        rpc_request = JSONRPC20Request(
+            method='SendMessage',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: SendMessageResponse = parse_lenient(
+            response_data['result'], SendMessageResponse()
+        )
+        return response
+
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        rpc_request = JSONRPC20Request(
+            method='SendStreamingMessage',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        async for event in self._send_stream_request(
+            dict(rpc_request.data),
+            context,
+        ):
+            yield event
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='GetTask',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: Task = parse_lenient(response_data['result'], Task())
+        return response
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        rpc_request = JSONRPC20Request(
+            method='ListTasks',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: ListTasksResponse = parse_lenient(
+            response_data['result'], ListTasksResponse()
+        )
+        return response
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='CancelTask',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: Task = parse_lenient(response_data['result'], Task())
+        return response
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='CreateTaskPushNotificationConfig',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: TaskPushNotificationConfig = parse_lenient(
+            response_data['result'], TaskPushNotificationConfig()
+        )
+        return response
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='GetTaskPushNotificationConfig',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: TaskPushNotificationConfig = parse_lenient(
+            response_data['result'], TaskPushNotificationConfig()
+        )
+        return response
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='ListTaskPushNotificationConfigs',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        response: ListTaskPushNotificationConfigsResponse = parse_lenient(
+            response_data['result'], ListTaskPushNotificationConfigsResponse()
+        )
+        return response
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        rpc_request = JSONRPC20Request(
+            method='DeleteTaskPushNotificationConfig',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        await self._send_request(dict(rpc_request.data), context)
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        rpc_request = JSONRPC20Request(
+            method='SubscribeToTask',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        async for event in self._send_stream_request(
+            dict(rpc_request.data),
+            context,
+        ):
+            yield event
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the agent's card."""
+        card = self.agent_card
+        if not card.capabilities.extended_agent_card:
+            return card
+
+        rpc_request = JSONRPC20Request(
+            method='GetExtendedAgentCard',
+            params=json_format.MessageToDict(request),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data),
+            context,
+        )
+        result = response_data['result']
+        # Validate type of the response
+        if not isinstance(result, dict):
+            raise A2AClientError(f'Invalid response type: {type(result)}')
+        response: AgentCard = parse_lenient(result, AgentCard())
+
+        return response
+
+    async def close(self) -> None:
+        """Closes the httpx client unless it is shared."""
+        if self.is_shared_httpx:
+            logger.debug(
+                'Cannot close a shared httpx client; only the provider '
+                'that supplied it via ClientConfig.httpx_client can close it.'
+            )
+            return
+        if self.httpx_client.is_closed:
+            raise A2AClientError('HTTP client is already closed')
+        try:
+            await self.httpx_client.aclose()
+        except Exception as e:
+            raise A2AClientError(f'Failed to close HTTP client: {e}') from e
+
+    def _create_jsonrpc_error(self, error_dict: dict[str, Any]) -> Exception:
+        """Creates the appropriate A2AError from a JSON-RPC error dictionary."""
+        code = error_dict.get('code')
+        message = error_dict.get('message', str(error_dict))
+        raw_data = error_dict.get('data')
+
+        a2a_data: dict[str, Any] | None = None
+        if isinstance(raw_data, list):
+            for d in raw_data:
+                if isinstance(d, dict) and d.get('@type') == _ERROR_INFO_TYPE:
+                    a2a_data = d.get('metadata') or None
+                    break
+
+        if isinstance(code, int) and code in _JSON_RPC_ERROR_CODE_TO_A2A_ERROR:
+            return _JSON_RPC_ERROR_CODE_TO_A2A_ERROR[code](
+                message, data=a2a_data
+            )
+
+        # Fallback to general A2AClientError
+        return A2AClientError(f'JSON-RPC Error {code}: {message}')
+
+    async def _send_request(
+        self,
+        payload: dict[str, Any],
+        context: ClientCallContext | None = None,
+    ) -> dict[str, Any]:
+        http_kwargs = get_http_args(context)
+
+        request = self.httpx_client.build_request(
+            'POST', self.url, json=payload, **(http_kwargs or {})
+        )
+        response_data = await send_http_request(self.httpx_client, request)
+        return self._check_jsonrpc_response(response_data)
+
+    def _check_jsonrpc_response(self, response_data: Any) -> dict[str, Any]:
+        """Returns a JSON-RPC success response, raising for anything else.
+
+        An error response raises the A2A error mapped from its code, even when
+        the error object lacks a ``message`` or carries extra members. A body
+        that is not a JSON-RPC 2.0 response object (a list, a string, an object
+        with neither ``result`` nor ``error``, or an ``error`` that is not an
+        object) raises ``A2AClientError`` instead of leaking a ``TypeError`` or
+        ``ValueError`` from the ``json-rpc`` package.
+        """
+        if not isinstance(response_data, dict):
+            raise A2AClientError(
+                'Invalid JSON-RPC response: expected an object, got '
+                f'{type(response_data).__name__}'
+            )
+        error = response_data.get('error')
+        if error:
+            if not isinstance(error, dict):
+                raise A2AClientError(
+                    f'Invalid JSON-RPC response: error is not an object: '
+                    f'{error!r}'
+                )
+            raise self._create_jsonrpc_error(error)
+        if 'result' not in response_data:
+            raise A2AClientError(
+                "Invalid JSON-RPC response: it has neither 'result' nor 'error'"
+            )
+        return response_data
+
+    async def _send_stream_request(
+        self,
+        rpc_request_payload: dict[str, Any],
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        http_kwargs = get_http_args(context)
+
+        async for sse_data in send_http_stream_request(
+            self.httpx_client,
+            'POST',
+            self.url,
+            None,
+            self._handle_sse_error,
+            json=rpc_request_payload,
+            **http_kwargs,
+        ):
+            try:
+                response_data = json.loads(sse_data)
+            except json.JSONDecodeError as e:
+                raise A2AClientError(
+                    f'Invalid JSON-RPC response in SSE stream: {e}'
+                ) from e
+            response_data = self._check_jsonrpc_response(response_data)
+            response: StreamResponse = parse_lenient(
+                response_data['result'], StreamResponse()
+            )
+            yield response
+
+    def _handle_sse_error(self, sse_data: str) -> NoReturn:
+        """Handles SSE error events by parsing JSON-RPC error payload and raising the appropriate domain error."""
+        try:
+            response_data = json.loads(sse_data)
+        except json.JSONDecodeError:
+            response_data = None
+        if isinstance(response_data, dict) and isinstance(
+            response_data.get('error'), dict
+        ):
+            raise self._create_jsonrpc_error(response_data['error'])
+        raise A2AClientError(f'SSE stream error: {sse_data}')
diff --git a/src/a2a/client/transports/rest.py b/src/a2a/client/transports/rest.py
new file mode 100644
index 000000000..82a72f650
--- /dev/null
+++ b/src/a2a/client/transports/rest.py
@@ -0,0 +1,462 @@
+import json
+import logging
+
+from collections.abc import AsyncGenerator
+from typing import Any, NoReturn
+from urllib.parse import quote
+
+import httpx
+
+from google.protobuf.json_format import MessageToDict
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.http_helpers import (
+    get_http_args,
+    handle_http_exceptions,
+    send_http_request,
+    send_http_stream_request,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.errors import A2A_REASON_TO_ERROR, MethodNotFoundError
+from a2a.utils.proto_utils import parse_lenient
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_rest_error(
+    error_payload: Any,
+    fallback_message: str,
+) -> Exception | None:
+    """Parses a REST error payload and returns the appropriate A2AError.
+
+    Args:
+        error_payload: The parsed JSON error payload. Any JSON value is
+            accepted, since a proxy or gateway may answer with a body that
+            is not a ``google.rpc.Status``.
+        fallback_message: Message to use if the payload has no ``message``.
+
+    Returns:
+        The mapped A2AError if a known reason was found, otherwise ``None``.
+    """
+    if not isinstance(error_payload, dict):
+        return None
+    error_data = error_payload.get('error')
+    if not isinstance(error_data, dict):
+        return None
+    message = error_data.get('message', fallback_message)
+    details = error_data.get('details', [])
+    if not isinstance(details, list):
+        return None
+
+    # The `details` array can contain multiple different error objects.
+    # We extract the first `ErrorInfo` object because it contains the
+    # specific `reason` code needed to map this back to a Python A2AError.
+    for d in details:
+        if (
+            isinstance(d, dict)
+            and d.get('@type') == 'type.googleapis.com/google.rpc.ErrorInfo'
+        ):
+            reason = d.get('reason')
+            metadata = d.get('metadata') or {}
+            if isinstance(reason, str):
+                exception_cls = A2A_REASON_TO_ERROR.get(reason)
+                if exception_cls:
+                    exc = exception_cls(message)
+                    if metadata:
+                        exc.data = metadata
+                    return exc
+            break
+
+    return None
+
+
+def _quote_id(value: str) -> str:
+    """Percent-encodes an id so it stays a single URL path segment."""
+    return quote(value, safe='')
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class RestTransport(ClientTransport):
+    """A REST transport for the A2A client."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        agent_card: AgentCard,
+        url: str,
+        is_shared_httpx: bool = False,
+    ):
+        """Initializes the RestTransport."""
+        self.url = url.removesuffix('/')
+        self.httpx_client = httpx_client
+        self.agent_card = agent_card
+        self.is_shared_httpx = is_shared_httpx
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+        response_data = await self._execute_request(
+            'POST',
+            '/message:send',
+            request.tenant,
+            context=context,
+            json=MessageToDict(request),
+        )
+        response: SendMessageResponse = parse_lenient(
+            response_data, SendMessageResponse()
+        )
+        return response
+
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        payload = MessageToDict(request)
+
+        async for event in self._send_stream_request(
+            'POST',
+            '/message:stream',
+            request.tenant,
+            context=context,
+            json=payload,
+        ):
+            yield event
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        params = MessageToDict(request)
+        if 'id' in params:
+            del params['id']  # id is part of the URL path
+        if 'tenant' in params:
+            del params['tenant']
+
+        response_data = await self._execute_request(
+            'GET',
+            f'/tasks/{_quote_id(request.id)}',
+            request.tenant,
+            context=context,
+            params=params,
+        )
+        response: Task = parse_lenient(response_data, Task())
+        return response
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        params = MessageToDict(request)
+        if 'tenant' in params:
+            del params['tenant']
+
+        response_data = await self._execute_request(
+            'GET',
+            '/tasks',
+            request.tenant,
+            context=context,
+            params=params,
+        )
+        response: ListTasksResponse = parse_lenient(
+            response_data, ListTasksResponse()
+        )
+        return response
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        response_data = await self._execute_request(
+            'POST',
+            f'/tasks/{_quote_id(request.id)}:cancel',
+            request.tenant,
+            context=context,
+            json=MessageToDict(request),
+        )
+        response: Task = parse_lenient(response_data, Task())
+        return response
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        response_data = await self._execute_request(
+            'POST',
+            f'/tasks/{_quote_id(request.task_id)}/pushNotificationConfigs',
+            request.tenant,
+            context=context,
+            json=MessageToDict(request),
+        )
+        response: TaskPushNotificationConfig = parse_lenient(
+            response_data, TaskPushNotificationConfig()
+        )
+        return response
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        params = MessageToDict(request)
+        if 'id' in params:
+            del params['id']
+        if 'taskId' in params:
+            del params['taskId']
+        if 'tenant' in params:
+            del params['tenant']
+
+        response_data = await self._execute_request(
+            'GET',
+            f'/tasks/{_quote_id(request.task_id)}'
+            f'/pushNotificationConfigs/{_quote_id(request.id)}',
+            request.tenant,
+            context=context,
+            params=params,
+        )
+        response: TaskPushNotificationConfig = parse_lenient(
+            response_data, TaskPushNotificationConfig()
+        )
+        return response
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        params = MessageToDict(request)
+        if 'taskId' in params:
+            del params['taskId']
+        if 'tenant' in params:
+            del params['tenant']
+
+        response_data = await self._execute_request(
+            'GET',
+            f'/tasks/{_quote_id(request.task_id)}/pushNotificationConfigs',
+            request.tenant,
+            context=context,
+            params=params,
+        )
+        response: ListTaskPushNotificationConfigsResponse = parse_lenient(
+            response_data, ListTaskPushNotificationConfigsResponse()
+        )
+        return response
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        params = MessageToDict(request)
+        if 'id' in params:
+            del params['id']
+        if 'taskId' in params:
+            del params['taskId']
+        if 'tenant' in params:
+            del params['tenant']
+
+        path = self._get_path(
+            f'/tasks/{_quote_id(request.task_id)}'
+            f'/pushNotificationConfigs/{_quote_id(request.id)}',
+            request.tenant,
+        )
+        http_request = self.httpx_client.build_request(
+            'DELETE',
+            f'{self.url}{path}',
+            params=params,
+            **get_http_args(context),
+        )
+        if self.httpx_client.is_closed:
+            raise A2AClientError('HTTP client is closed')
+        # The body is not read: servers confirm the deletion with `{}`,
+        # with 204 No Content, or with a 200 that has no body.
+        with handle_http_exceptions(self._handle_http_error):
+            response = await self.httpx_client.send(http_request)
+            response.raise_for_status()
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        async for event in self._send_stream_request(
+            'POST',
+            f'/tasks/{_quote_id(request.id)}:subscribe',
+            request.tenant,
+            context=context,
+        ):
+            yield event
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the Extended AgentCard."""
+        card = self.agent_card
+        if not card.capabilities.extended_agent_card:
+            return card
+
+        response_data = await self._execute_request(
+            'GET', '/extendedAgentCard', request.tenant, context=context
+        )
+
+        return parse_lenient(response_data, AgentCard())
+
+    async def close(self) -> None:
+        """Closes the httpx client unless it is shared."""
+        if self.is_shared_httpx:
+            logger.debug(
+                'Cannot close a shared httpx client; only the provider '
+                'that supplied it via ClientConfig.httpx_client can close it.'
+            )
+            return
+        if self.httpx_client.is_closed:
+            raise A2AClientError('HTTP client is already closed')
+        try:
+            await self.httpx_client.aclose()
+        except Exception as e:
+            raise A2AClientError(f'Failed to close HTTP client: {e}') from e
+
+    def _get_path(self, base_path: str, tenant: str) -> str:
+        """Returns the full path, prepending the tenant if provided."""
+        return f'/{tenant}{base_path}' if tenant else base_path
+
+    def _handle_http_error(self, e: httpx.HTTPStatusError) -> NoReturn:
+        """Handles HTTP status errors and raises the appropriate A2AError."""
+        try:
+            error_payload = e.response.json()
+            mapped = _parse_rest_error(error_payload, str(e))
+            if mapped:
+                raise mapped from e
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+        status_code = e.response.status_code
+        if status_code == httpx.codes.NOT_FOUND:
+            raise MethodNotFoundError(
+                f'Resource not found: {e.request.url}'
+            ) from e
+
+        raise A2AClientError(f'HTTP Error {status_code}: {e}') from e
+
+    def _handle_sse_error(self, sse_data: str) -> NoReturn:
+        """Handles SSE error events by parsing the REST error payload and raising the appropriate A2AError."""
+        error_payload = json.loads(sse_data)
+        mapped = _parse_rest_error(error_payload, sse_data)
+        if mapped:
+            raise mapped
+        raise A2AClientError(sse_data)
+
+    async def _send_stream_request(
+        self,
+        method: str,
+        target: str,
+        tenant: str,
+        context: ClientCallContext | None = None,
+        *,
+        json: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        path = self._get_path(target, tenant)
+        http_kwargs = get_http_args(context)
+
+        async for sse_data in send_http_stream_request(
+            self.httpx_client,
+            method,
+            f'{self.url}{path}',
+            self._handle_http_error,
+            self._handle_sse_error,
+            json=json,
+            **http_kwargs,
+        ):
+            event: StreamResponse = parse_lenient(sse_data, StreamResponse())
+            if event.WhichOneof('payload') is None:
+                self._raise_in_band_error(sse_data)
+            yield event
+
+    def _raise_in_band_error(self, sse_data: str) -> None:
+        """Raises the error carried by a data event, if it carries one.
+
+        The HTTP+JSON binding defines no SSE event type for errors, so a
+        server may send the ``google.rpc.Status`` body as an ordinary data
+        event instead of an ``event: error`` one. ``StreamResponse`` has no
+        ``error`` field, so that body parses to an event with no payload.
+        """
+        payload = json.loads(sse_data)
+        if isinstance(payload, dict) and 'error' in payload:
+            self._handle_sse_error(sse_data)
+
+    async def _send_request(self, request: httpx.Request) -> dict[str, Any]:
+        return await send_http_request(
+            self.httpx_client, request, self._handle_http_error
+        )
+
+    async def _execute_request(  # noqa: PLR0913
+        self,
+        method: str,
+        target: str,
+        tenant: str,
+        context: ClientCallContext | None = None,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        path = self._get_path(target, tenant)
+        http_kwargs = get_http_args(context)
+
+        request = self.httpx_client.build_request(
+            method,
+            f'{self.url}{path}',
+            json=json,
+            params=params,
+            **http_kwargs,
+        )
+        return await self._send_request(request)
diff --git a/src/a2a/client/transports/tenant_decorator.py b/src/a2a/client/transports/tenant_decorator.py
new file mode 100644
index 000000000..d1059d757
--- /dev/null
+++ b/src/a2a/client/transports/tenant_decorator.py
@@ -0,0 +1,167 @@
+from collections.abc import AsyncGenerator
+
+from a2a.client.client import ClientCallContext
+from a2a.client.transports.base import ClientTransport
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+
+
+class TenantTransportDecorator(ClientTransport):
+    """A transport decorator that attaches a tenant to all requests."""
+
+    def __init__(self, base: ClientTransport, tenant: str):
+        self._base = base
+        self._tenant = tenant
+
+    def _resolve_tenant(self, tenant: str) -> str:
+        """If tenant is not provided, use the default tenant.
+
+        Returns:
+            The tenant used for the request.
+        """
+        return tenant or self._tenant
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.send_message(request, context=context)
+
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        async for event in self._base.send_message_streaming(
+            request, context=context
+        ):
+            yield event
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.get_task(request, context=context)
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.list_tasks(request, context=context)
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.cancel_task(request, context=context)
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.create_task_push_notification_config(
+            request, context=context
+        )
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.get_task_push_notification_config(
+            request, context=context
+        )
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.list_task_push_notification_configs(
+            request, context=context
+        )
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        await self._base.delete_task_push_notification_config(
+            request, context=context
+        )
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        async for event in self._base.subscribe(request, context=context):
+            yield event
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the Extended AgentCard."""
+        request.tenant = self._resolve_tenant(request.tenant)
+        return await self._base.get_extended_agent_card(
+            request,
+            context=context,
+        )
+
+    async def close(self) -> None:
+        """Closes the transport."""
+        await self._base.close()
diff --git a/src/a2a/compat/__init__.py b/src/a2a/compat/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/a2a/compat/v0_3/README.md b/src/a2a/compat/v0_3/README.md
new file mode 100644
index 000000000..4c705535a
--- /dev/null
+++ b/src/a2a/compat/v0_3/README.md
@@ -0,0 +1,54 @@
+# A2A Protocol Backward Compatibility (v0.3)
+
+This directory (`src/a2a/compat/v0_3/`) provides the foundational types and translation layers necessary for modern `v1.0` clients and servers to interoperate with legacy `v0.3` A2A systems.
+
+## Data Representations
+
+To support cross-version compatibility across JSON, REST, and gRPC, this directory manages three distinct data representations:
+
+### 1. Legacy v0.3 Pydantic Models (`types.py`)
+This file contains Python [Pydantic](https://docs.pydantic.dev/) models generated from the legacy v0.3 JSON schema. 
+* **Purpose**: This is the "pivot" format. Legacy JSON-RPC and REST implementations natively serialize to/from these models. It acts as the intermediary between old wire formats and the modern SDK.
+
+### 2. Legacy v0.3 Protobuf Bindings (`a2a_v0_3_pb2.py`)
+This module contains the native Protobuf bindings for the legacy v0.3 gRPC protocol.
+* **Purpose**: To decode incoming bytes from legacy gRPC clients or encode outbound bytes to legacy gRPC servers. 
+* **Note**: It is generated into the `a2a.v1` package namespace.
+
+### 3. Current v1.0 Protobuf Bindings (`a2a.types.a2a_pb2`)
+This is the central source of truth for the modern SDK (`v1.0`). All legacy payloads must ultimately be translated into these `v1.0` core objects to be processed by the modern `AgentExecutor`.
+* **Note**: It is generated into the `lf.a2a.v1` package namespace.
+---
+
+## Transformation Utilities
+
+Payloads arriving from legacy clients undergo a phased transformation to bridge the gap between versions.
+
+### Legacy gRPC ↔ Legacy Pydantic: `proto_utils.py`
+This module handles the mapping between legacy `v0.3` gRPC Protobuf objects and legacy `v0.3` Pydantic models.
+This is a copy of the `a2a.types.proto_utils` module from 0.3 release.
+
+```python
+from a2a.compat.v0_3 import a2a_v0_3_pb2
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3 import proto_utils
+
+# 1. Receive legacy bytes over the wire
+legacy_pb_msg = a2a_v0_3_pb2.Message()
+legacy_pb_msg.ParseFromString(wire_bytes)
+
+# 2. Convert to intermediate Pydantic representation
+pydantic_msg: types_v03.Message = proto_utils.FromProto.message(legacy_pb_msg)
+```
+
+### Legacy Pydantic ↔ Modern v1.0 Protobuf: `conversions.py`
+This module structurally translates between legacy `v0.3` Pydantic objects and modern `v1.0` Core Protobufs.
+
+```python
+from a2a.types import a2a_pb2 as pb2_v10
+from a2a.compat.v0_3 import conversions
+
+# 3. Convert the legacy Pydantic object into a modern v1.0 Protobuf
+core_pb_msg: pb2_v10.Message = conversions.to_core_message(pydantic_msg)
+
+```
diff --git a/src/a2a/compat/v0_3/__init__.py b/src/a2a/compat/v0_3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/a2a/compat/v0_3/a2a_v0_3.proto b/src/a2a/compat/v0_3/a2a_v0_3.proto
new file mode 100644
index 000000000..41eaa0341
--- /dev/null
+++ b/src/a2a/compat/v0_3/a2a_v0_3.proto
@@ -0,0 +1,735 @@
+// Older protoc compilers don't understand edition yet.
+syntax = "proto3";
+package a2a.v1;
+
+import "google/api/annotations.proto";
+import "google/api/client.proto";
+import "google/api/field_behavior.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+
+option csharp_namespace = "A2a.V1";
+option go_package = "google.golang.org/a2a/v1";
+option java_multiple_files = true;
+option java_outer_classname = "A2A";
+option java_package = "com.google.a2a.v1";
+
+// A2AService defines the gRPC version of the A2A protocol. This has a slightly
+// different shape than the JSONRPC version to better conform to AIP-127,
+// where appropriate. The nouns are AgentCard, Message, Task and
+// TaskPushNotificationConfig.
+// - Messages are not a standard resource so there is no get/delete/update/list
+//   interface, only a send and stream custom methods.
+// - Tasks have a get interface and custom cancel and subscribe methods.
+// - TaskPushNotificationConfig are a resource whose parent is a task.
+//   They have get, list and create methods.
+// - AgentCard is a static resource with only a get method.
+service A2AService {
+  // Send a message to the agent. This is a blocking call that will return the
+  // task once it is completed, or a LRO if requested.
+  rpc SendMessage(SendMessageRequest) returns (SendMessageResponse) {
+    option (google.api.http) = {
+      post: "/v1/message:send"
+      body: "*"
+    };
+  }
+  // SendStreamingMessage is a streaming call that will return a stream of
+  // task update events until the Task is in an interrupted or terminal state.
+  rpc SendStreamingMessage(SendMessageRequest) returns (stream StreamResponse) {
+    option (google.api.http) = {
+      post: "/v1/message:stream"
+      body: "*"
+    };
+  }
+
+  // Get the current state of a task from the agent.
+  rpc GetTask(GetTaskRequest) returns (Task) {
+    option (google.api.http) = {
+      get: "/v1/{name=tasks/*}"
+    };
+    option (google.api.method_signature) = "name";
+  }
+  // Cancel a task from the agent. If supported one should expect no
+  // more task updates for the task.
+  rpc CancelTask(CancelTaskRequest) returns (Task) {
+    option (google.api.http) = {
+      post: "/v1/{name=tasks/*}:cancel"
+      body: "*"
+    };
+  }
+  // TaskSubscription is a streaming call that will return a stream of task
+  // update events. This attaches the stream to an existing in process task.
+  // If the task is complete the stream will return the completed task (like
+  // GetTask) and close the stream.
+  rpc TaskSubscription(TaskSubscriptionRequest)
+      returns (stream StreamResponse) {
+    option (google.api.http) = {
+      get: "/v1/{name=tasks/*}:subscribe"
+    };
+  }
+
+  // Set a push notification config for a task.
+  rpc CreateTaskPushNotificationConfig(CreateTaskPushNotificationConfigRequest)
+      returns (TaskPushNotificationConfig) {
+    option (google.api.http) = {
+      post: "/v1/{parent=tasks/*/pushNotificationConfigs}"
+      body: "config"
+    };
+    option (google.api.method_signature) = "parent,config";
+  }
+  // Get a push notification config for a task.
+  rpc GetTaskPushNotificationConfig(GetTaskPushNotificationConfigRequest)
+      returns (TaskPushNotificationConfig) {
+    option (google.api.http) = {
+      get: "/v1/{name=tasks/*/pushNotificationConfigs/*}"
+    };
+    option (google.api.method_signature) = "name";
+  }
+  // Get a list of push notifications configured for a task.
+  rpc ListTaskPushNotificationConfig(ListTaskPushNotificationConfigRequest)
+      returns (ListTaskPushNotificationConfigResponse) {
+    option (google.api.http) = {
+      get: "/v1/{parent=tasks/*}/pushNotificationConfigs"
+    };
+    option (google.api.method_signature) = "parent";
+  }
+  // GetAgentCard returns the agent card for the agent.
+  rpc GetAgentCard(GetAgentCardRequest) returns (AgentCard) {
+    option (google.api.http) = {
+      get: "/v1/card"
+    };
+  }
+  // Delete a push notification config for a task.
+  rpc DeleteTaskPushNotificationConfig(DeleteTaskPushNotificationConfigRequest)
+      returns (google.protobuf.Empty) {
+    option (google.api.http) = {
+      delete: "/v1/{name=tasks/*/pushNotificationConfigs/*}"
+    };
+    option (google.api.method_signature) = "name";
+  }
+}
+
+///////// Data Model ////////////
+
+// Configuration of a send message request.
+message SendMessageConfiguration {
+  // The output modes that the agent is expected to respond with.
+  repeated string accepted_output_modes = 1;
+  // A configuration of a webhook that can be used to receive updates
+  PushNotificationConfig push_notification = 2;
+  // The maximum number of messages to include in the history. if 0, the
+  // history will be unlimited.
+  int32 history_length = 3;
+  // If true, the message will be blocking until the task is completed. If
+  // false, the message will be non-blocking and the task will be returned
+  // immediately. It is the caller's responsibility to check for any task
+  // updates.
+  bool blocking = 4;
+}
+
+// Task is the core unit of action for A2A. It has a current status
+// and when results are created for the task they are stored in the
+// artifact. If there are multiple turns for a task, these are stored in
+// history.
+message Task {
+  // Unique identifier (e.g. UUID) for the task, generated by the server for a
+  // new task.
+  string id = 1;
+  // Unique identifier (e.g. UUID) for the contextual collection of interactions
+  // (tasks and messages). Created by the A2A server.
+  string context_id = 2;
+  // The current status of a Task, including state and a message.
+  TaskStatus status = 3;
+  // A set of output artifacts for a Task.
+  repeated Artifact artifacts = 4;
+  // protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
+  // The history of interactions from a task.
+  repeated Message history = 5;
+  // protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
+  // A key/value object to store custom metadata about a task.
+  google.protobuf.Struct metadata = 6;
+}
+
+// The set of states a Task can be in.
+enum TaskState {
+  TASK_STATE_UNSPECIFIED = 0;
+  // Represents the status that acknowledges a task is created
+  TASK_STATE_SUBMITTED = 1;
+  // Represents the status that a task is actively being processed
+  TASK_STATE_WORKING = 2;
+  // Represents the status a task is finished. This is a terminal state
+  TASK_STATE_COMPLETED = 3;
+  // Represents the status a task is done but failed. This is a terminal state
+  TASK_STATE_FAILED = 4;
+  // Represents the status a task was cancelled before it finished.
+  // This is a terminal state.
+  TASK_STATE_CANCELLED = 5;
+  // Represents the status that the task requires information to complete.
+  // This is an interrupted state.
+  TASK_STATE_INPUT_REQUIRED = 6;
+  // Represents the status that the agent has decided to not perform the task.
+  // This may be done during initial task creation or later once an agent
+  // has determined it can't or won't proceed. This is a terminal state.
+  TASK_STATE_REJECTED = 7;
+  // Represents the state that some authentication is needed from the upstream
+  // client. Authentication is expected to come out-of-band thus this is not
+  // an interrupted or terminal state.
+  TASK_STATE_AUTH_REQUIRED = 8;
+}
+
+// A container for the status of a task
+message TaskStatus {
+  // The current state of this task
+  TaskState state = 1;
+  // A message associated with the status.
+  Message update = 2 [json_name = "message"];
+  // Timestamp when the status was recorded.
+  // Example: "2023-10-27T10:00:00Z"
+  google.protobuf.Timestamp timestamp = 3;
+}
+
+// Part represents a container for a section of communication content.
+// Parts can be purely textual, some sort of file (image, video, etc) or
+// a structured data blob (i.e. JSON).
+message Part {
+  oneof part {
+    string text = 1;
+    FilePart file = 2;
+    DataPart data = 3;
+  }
+  // Optional metadata associated with this part.
+  google.protobuf.Struct metadata = 4;
+}
+
+// FilePart represents the different ways files can be provided. If files are
+// small, directly feeding the bytes is supported via file_with_bytes. If the
+// file is large, the agent should read the content as appropriate directly
+// from the file_with_uri source.
+message FilePart {
+  oneof file {
+    string file_with_uri = 1;
+    bytes file_with_bytes = 2;
+  }
+  string mime_type = 3;
+  string name = 4;
+}
+
+// DataPart represents a structured blob. This is most commonly a JSON payload.
+message DataPart {
+  google.protobuf.Struct data = 1;
+}
+
+enum Role {
+  ROLE_UNSPECIFIED = 0;
+  // USER role refers to communication from the client to the server.
+  ROLE_USER = 1;
+  // AGENT role refers to communication from the server to the client.
+  ROLE_AGENT = 2;
+}
+
+// Message is one unit of communication between client and server. It is
+// associated with a context and optionally a task. Since the server is
+// responsible for the context definition, it must always provide a context_id
+// in its messages. The client can optionally provide the context_id if it
+// knows the context to associate the message to. Similarly for task_id,
+// except the server decides if a task is created and whether to include the
+// task_id.
+message Message {
+  // The unique identifier (e.g. UUID)of the message. This is required and
+  // created by the message creator.
+  string message_id = 1;
+  // The context id of the message. This is optional and if set, the message
+  // will be associated with the given context.
+  string context_id = 2;
+  // The task id of the message. This is optional and if set, the message
+  // will be associated with the given task.
+  string task_id = 3;
+  // A role for the message.
+  Role role = 4;
+  // protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
+  // Content is the container of the message content.
+  repeated Part content = 5;
+  // protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
+  // Any optional metadata to provide along with the message.
+  google.protobuf.Struct metadata = 6;
+  // The URIs of extensions that are present or contributed to this Message.
+  repeated string extensions = 7;
+}
+
+// Artifacts are the container for task completed results. These are similar
+// to Messages but are intended to be the product of a task, as opposed to
+// point-to-point communication.
+message Artifact {
+  // Unique identifier (e.g. UUID) for the artifact. It must be at least unique
+  // within a task.
+  string artifact_id = 1;
+  // A human readable name for the artifact.
+  string name = 3;
+  // A human readable description of the artifact, optional.
+  string description = 4;
+  // The content of the artifact.
+  repeated Part parts = 5;
+  // Optional metadata included with the artifact.
+  google.protobuf.Struct metadata = 6;
+  // The URIs of extensions that are present or contributed to this Artifact.
+  repeated string extensions = 7;
+}
+
+// TaskStatusUpdateEvent is a delta even on a task indicating that a task
+// has changed.
+message TaskStatusUpdateEvent {
+  // The id of the task that is changed
+  string task_id = 1;
+  // The id of the context that the task belongs to
+  string context_id = 2;
+  // The new status of the task.
+  TaskStatus status = 3;
+  // Whether this is the last status update expected for this task.
+  bool final = 4;
+  // Optional metadata to associate with the task update.
+  google.protobuf.Struct metadata = 5;
+}
+
+// TaskArtifactUpdateEvent represents a task delta where an artifact has
+// been generated.
+message TaskArtifactUpdateEvent {
+  // The id of the task for this artifact
+  string task_id = 1;
+  // The id of the context that this task belongs too
+  string context_id = 2;
+  // The artifact itself
+  Artifact artifact = 3;
+  //  Whether this should be appended to a prior one produced
+  bool append = 4;
+  // Whether this represents the last part of an artifact
+  bool last_chunk = 5;
+  // Optional metadata associated with the artifact update.
+  google.protobuf.Struct metadata = 6;
+}
+
+// Configuration for setting up push notifications for task updates.
+message PushNotificationConfig {
+  // A unique identifier (e.g. UUID) for this push notification.
+  string id = 1;
+  // Url to send the notification too
+  string url = 2;
+  // Token unique for this task/session
+  string token = 3;
+  // Information about the authentication to sent with the notification
+  AuthenticationInfo authentication = 4;
+}
+
+// Defines authentication details, used for push notifications.
+message AuthenticationInfo {
+  // Supported authentication schemes - e.g. Basic, Bearer, etc
+  repeated string schemes = 1;
+  // Optional credentials
+  string credentials = 2;
+}
+
+// Defines additional transport information for the agent.
+message AgentInterface {
+  // The url this interface is found at.
+  string url = 1;
+  // The transport supported this url. This is an open form string, to be
+  // easily extended for many transport protocols. The core ones officially
+  // supported are JSONRPC, GRPC and HTTP+JSON.
+  string transport = 2;
+}
+
+// AgentCard conveys key information:
+// - Overall details (version, name, description, uses)
+// - Skills; a set of actions/solutions the agent can perform
+// - Default modalities/content types supported by the agent.
+// - Authentication requirements
+// Next ID: 19
+message AgentCard {
+  // The version of the A2A protocol this agent supports.
+  string protocol_version = 16;
+  // A human readable name for the agent.
+  // Example: "Recipe Agent"
+  string name = 1;
+  // A description of the agent's domain of action/solution space.
+  // Example: "Agent that helps users with recipes and cooking."
+  string description = 2;
+  // A URL to the address the agent is hosted at. This represents the
+  // preferred endpoint as declared by the agent.
+  string url = 3;
+  // The transport of the preferred endpoint. If empty, defaults to JSONRPC.
+  string preferred_transport = 14;
+  // Announcement of additional supported transports. Client can use any of
+  // the supported transports.
+  repeated AgentInterface additional_interfaces = 15;
+  // The service provider of the agent.
+  AgentProvider provider = 4;
+  // The version of the agent.
+  // Example: "1.0.0"
+  string version = 5;
+  // A url to provide additional documentation about the agent.
+  string documentation_url = 6;
+  // A2A Capability set supported by the agent.
+  AgentCapabilities capabilities = 7;
+  // The security scheme details used for authenticating with this agent.
+  map<string, SecurityScheme> security_schemes = 8;
+  // protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
+  // Security requirements for contacting the agent.
+  // This list can be seen as an OR of ANDs. Each object in the list describes
+  // one possible set of security requirements that must be present on a
+  // request. This allows specifying, for example, "callers must either use
+  // OAuth OR an API Key AND mTLS."
+  // Example:
+  // security {
+  //   schemes { key: "oauth" value { list: ["read"] } }
+  // }
+  // security {
+  //   schemes { key: "api-key" }
+  //   schemes { key: "mtls" }
+  // }
+  repeated Security security = 9;
+  // protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
+  // The set of interaction modes that the agent supports across all skills.
+  // This can be overridden per skill. Defined as mime types.
+  repeated string default_input_modes = 10;
+  // The mime types supported as outputs from this agent.
+  repeated string default_output_modes = 11;
+  // Skills represent a unit of ability an agent can perform. This may
+  // somewhat abstract but represents a more focused set of actions that the
+  // agent is highly likely to succeed at.
+  repeated AgentSkill skills = 12;
+  // Whether the agent supports providing an extended agent card when
+  // the user is authenticated, i.e. is the card from .well-known
+  // different than the card from GetAgentCard.
+  bool supports_authenticated_extended_card = 13;
+  // JSON Web Signatures computed for this AgentCard.
+  repeated AgentCardSignature signatures = 17;
+  // An optional URL to an icon for the agent.
+  string icon_url = 18;
+}
+
+// Represents information about the service provider of an agent.
+message AgentProvider {
+  // The providers reference url
+  // Example: "https://ai.google.dev"
+  string url = 1;
+  // The providers organization name
+  // Example: "Google"
+  string organization = 2;
+}
+
+// Defines the A2A feature set supported by the agent
+message AgentCapabilities {
+  // If the agent will support streaming responses
+  bool streaming = 1;
+  // If the agent can send push notifications to the clients webhook
+  bool push_notifications = 2;
+  // Extensions supported by this agent.
+  repeated AgentExtension extensions = 3;
+}
+
+// A declaration of an extension supported by an Agent.
+message AgentExtension {
+  // The URI of the extension.
+  // Example: "https://developers.google.com/identity/protocols/oauth2"
+  string uri = 1;
+  // A description of how this agent uses this extension.
+  // Example: "Google OAuth 2.0 authentication"
+  string description = 2;
+  // Whether the client must follow specific requirements of the extension.
+  // Example: false
+  bool required = 3;
+  // Optional configuration for the extension.
+  google.protobuf.Struct params = 4;
+}
+
+// AgentSkill represents a unit of action/solution that the agent can perform.
+// One can think of this as a type of highly reliable solution that an agent
+// can be tasked to provide. Agents have the autonomy to choose how and when
+// to use specific skills, but clients should have confidence that if the
+// skill is defined that unit of action can be reliably performed.
+message AgentSkill {
+  // Unique identifier of the skill within this agent.
+  string id = 1;
+  // A human readable name for the skill.
+  string name = 2;
+  // A human (or llm) readable description of the skill
+  // details and behaviors.
+  string description = 3;
+  // A set of tags for the skill to enhance categorization/utilization.
+  // Example: ["cooking", "customer support", "billing"]
+  repeated string tags = 4;
+  // A set of example queries that this skill is designed to address.
+  // These examples should help the caller to understand how to craft requests
+  // to the agent to achieve specific goals.
+  // Example: ["I need a recipe for bread"]
+  repeated string examples = 5;
+  // Possible input modalities supported.
+  repeated string input_modes = 6;
+  // Possible output modalities produced
+  repeated string output_modes = 7;
+  // protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
+  // Security schemes necessary for the agent to leverage this skill.
+  // As in the overall AgentCard.security, this list represents a logical OR of
+  // security requirement objects. Each object is a set of security schemes
+  // that must be used together (a logical AND).
+  repeated Security security = 8;
+  // protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
+}
+
+// AgentCardSignature represents a JWS signature of an AgentCard.
+// This follows the JSON format of an RFC 7515 JSON Web Signature (JWS).
+message AgentCardSignature {
+  // The protected JWS header for the signature. This is always a
+  // base64url-encoded JSON object. Required.
+  string protected = 1 [(google.api.field_behavior) = REQUIRED];
+  // The computed signature, base64url-encoded. Required.
+  string signature = 2 [(google.api.field_behavior) = REQUIRED];
+  // The unprotected JWS header values.
+  google.protobuf.Struct header = 3;
+}
+
+message TaskPushNotificationConfig {
+  // The resource name of the config.
+  // Format: tasks/{task_id}/pushNotificationConfigs/{config_id}
+  string name = 1;
+  // The push notification configuration details.
+  PushNotificationConfig push_notification_config = 2;
+}
+
+// protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
+message StringList {
+  repeated string list = 1;
+}
+// protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
+
+message Security {
+  map<string, StringList> schemes = 1;
+}
+
+message SecurityScheme {
+  oneof scheme {
+    APIKeySecurityScheme api_key_security_scheme = 1;
+    HTTPAuthSecurityScheme http_auth_security_scheme = 2;
+    OAuth2SecurityScheme oauth2_security_scheme = 3;
+    OpenIdConnectSecurityScheme open_id_connect_security_scheme = 4;
+    MutualTlsSecurityScheme mtls_security_scheme = 5;
+  }
+}
+
+message APIKeySecurityScheme {
+  // Description of this security scheme.
+  string description = 1;
+  // Location of the API key, valid values are "query", "header", or "cookie"
+  string location = 2;
+  // Name of the header, query or cookie parameter to be used.
+  string name = 3;
+}
+
+message HTTPAuthSecurityScheme {
+  // Description of this security scheme.
+  string description = 1;
+  // The name of the HTTP Authentication scheme to be used in the
+  // Authorization header as defined in RFC7235. The values used SHOULD be
+  // registered in the IANA Authentication Scheme registry.
+  // The value is case-insensitive, as defined in RFC7235.
+  string scheme = 2;
+  // A hint to the client to identify how the bearer token is formatted.
+  // Bearer tokens are usually generated by an authorization server, so
+  // this information is primarily for documentation purposes.
+  string bearer_format = 3;
+}
+
+message OAuth2SecurityScheme {
+  // Description of this security scheme.
+  string description = 1;
+  // An object containing configuration information for the flow types supported
+  OAuthFlows flows = 2;
+  // URL to the oauth2 authorization server metadata
+  // [RFC8414](https://datatracker.ietf.org/doc/html/rfc8414). TLS is required.
+  string oauth2_metadata_url = 3;
+}
+
+message OpenIdConnectSecurityScheme {
+  // Description of this security scheme.
+  string description = 1;
+  // Well-known URL to discover the [[OpenID-Connect-Discovery]] provider
+  // metadata.
+  string open_id_connect_url = 2;
+}
+
+message MutualTlsSecurityScheme {
+  // Description of this security scheme.
+  string description = 1;
+}
+
+message OAuthFlows {
+  oneof flow {
+    AuthorizationCodeOAuthFlow authorization_code = 1;
+    ClientCredentialsOAuthFlow client_credentials = 2;
+    ImplicitOAuthFlow implicit = 3;
+    PasswordOAuthFlow password = 4;
+  }
+}
+
+message AuthorizationCodeOAuthFlow {
+  // The authorization URL to be used for this flow. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS
+  string authorization_url = 1;
+  // The token URL to be used for this flow. This MUST be in the form of a URL.
+  // The OAuth2 standard requires the use of TLS.
+  string token_url = 2;
+  // The URL to be used for obtaining refresh tokens. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS.
+  string refresh_url = 3;
+  // The available scopes for the OAuth2 security scheme. A map between the
+  // scope name and a short description for it. The map MAY be empty.
+  map<string, string> scopes = 4;
+}
+
+message ClientCredentialsOAuthFlow {
+  // The token URL to be used for this flow. This MUST be in the form of a URL.
+  // The OAuth2 standard requires the use of TLS.
+  string token_url = 1;
+  // The URL to be used for obtaining refresh tokens. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS.
+  string refresh_url = 2;
+  // The available scopes for the OAuth2 security scheme. A map between the
+  // scope name and a short description for it. The map MAY be empty.
+  map<string, string> scopes = 3;
+}
+
+message ImplicitOAuthFlow {
+  // The authorization URL to be used for this flow. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS
+  string authorization_url = 1;
+  // The URL to be used for obtaining refresh tokens. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS.
+  string refresh_url = 2;
+  // The available scopes for the OAuth2 security scheme. A map between the
+  // scope name and a short description for it. The map MAY be empty.
+  map<string, string> scopes = 3;
+}
+
+message PasswordOAuthFlow {
+  // The token URL to be used for this flow. This MUST be in the form of a URL.
+  // The OAuth2 standard requires the use of TLS.
+  string token_url = 1;
+  // The URL to be used for obtaining refresh tokens. This MUST be in the
+  // form of a URL. The OAuth2 standard requires the use of TLS.
+  string refresh_url = 2;
+  // The available scopes for the OAuth2 security scheme. A map between the
+  // scope name and a short description for it. The map MAY be empty.
+  map<string, string> scopes = 3;
+}
+
+///////////// Request Messages ///////////
+message SendMessageRequest {
+  // The message to send to the agent.
+  Message request = 1
+      [(google.api.field_behavior) = REQUIRED, json_name = "message"];
+  // Configuration for the send request.
+  SendMessageConfiguration configuration = 2;
+  // Optional metadata for the request.
+  google.protobuf.Struct metadata = 3;
+}
+
+message GetTaskRequest {
+  // The resource name of the task.
+  // Format: tasks/{task_id}
+  string name = 1 [(google.api.field_behavior) = REQUIRED];
+  // The number of most recent messages from the task's history to retrieve.
+  int32 history_length = 2;
+}
+
+message CancelTaskRequest {
+  // The resource name of the task to cancel.
+  // Format: tasks/{task_id}
+  string name = 1;
+}
+
+message GetTaskPushNotificationConfigRequest {
+  // The resource name of the config to retrieve.
+  // Format: tasks/{task_id}/pushNotificationConfigs/{config_id}
+  string name = 1;
+}
+
+message DeleteTaskPushNotificationConfigRequest {
+  // The resource name of the config to delete.
+  // Format: tasks/{task_id}/pushNotificationConfigs/{config_id}
+  string name = 1;
+}
+
+message CreateTaskPushNotificationConfigRequest {
+  // The parent task resource for this config.
+  // Format: tasks/{task_id}
+  string parent = 1 [
+    (google.api.field_behavior) = REQUIRED
+  ];
+  // The ID for the new config.
+  string config_id = 2 [(google.api.field_behavior) = REQUIRED];
+  // The configuration to create.
+  TaskPushNotificationConfig config = 3
+      [(google.api.field_behavior) = REQUIRED];
+}
+
+message TaskSubscriptionRequest {
+  // The resource name of the task to subscribe to.
+  // Format: tasks/{task_id}
+  string name = 1;
+}
+
+message ListTaskPushNotificationConfigRequest {
+  // The parent task resource.
+  // Format: tasks/{task_id}
+  string parent = 1;
+  // For AIP-158 these fields are present. Usually not used/needed.
+  // The maximum number of configurations to return.
+  // If unspecified, all configs will be returned.
+  int32 page_size = 2;
+
+  // A page token received from a previous
+  // ListTaskPushNotificationConfigRequest call.
+  // Provide this to retrieve the subsequent page.
+  // When paginating, all other parameters provided to
+  // `ListTaskPushNotificationConfigRequest` must match the call that provided
+  // the page token.
+  string page_token = 3;
+}
+
+message GetAgentCardRequest {
+  // Empty. Added to fix linter violation.
+}
+
+//////// Response Messages ///////////
+message SendMessageResponse {
+  oneof payload {
+    Task task = 1;
+    Message msg = 2 [json_name = "message"];
+  }
+}
+
+// The stream response for a message. The stream should be one of the following
+// sequences:
+// If the response is a message, the stream should contain one, and only one,
+// message and then close
+// If the response is a task lifecycle, the first response should be a Task
+// object followed by zero or more TaskStatusUpdateEvents and
+// TaskArtifactUpdateEvents. The stream should complete when the Task
+// if in an interrupted or terminal state. A stream that ends before these
+// conditions are met are
+message StreamResponse {
+  oneof payload {
+    Task task = 1;
+    Message msg = 2 [json_name = "message"];
+    TaskStatusUpdateEvent status_update = 3;
+    TaskArtifactUpdateEvent artifact_update = 4;
+  }
+}
+
+message ListTaskPushNotificationConfigResponse {
+  // The list of push notification configurations.
+  repeated TaskPushNotificationConfig configs = 1;
+  // A token, which can be sent as `page_token` to retrieve the next page.
+  // If this field is omitted, there are no subsequent pages.
+  string next_page_token = 2;
+}
diff --git a/src/a2a/compat/v0_3/a2a_v0_3_pb2.py b/src/a2a/compat/v0_3/a2a_v0_3_pb2.py
new file mode 100644
index 000000000..e310e530b
--- /dev/null
+++ b/src/a2a/compat/v0_3/a2a_v0_3_pb2.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: a2a_v0_3.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'a2a_v0_3.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2
+from google.api import client_pb2 as google_dot_api_dot_client__pb2
+from google.api import field_behavior_pb2 as google_dot_api_dot_field__behavior__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0e\x61\x32\x61_v0_3.proto\x12\x06\x61\x32\x61.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xde\x01\n\x18SendMessageConfiguration\x12\x32\n\x15\x61\x63\x63\x65pted_output_modes\x18\x01 \x03(\tR\x13\x61\x63\x63\x65ptedOutputModes\x12K\n\x11push_notification\x18\x02 \x01(\x0b\x32\x1e.a2a.v1.PushNotificationConfigR\x10pushNotification\x12%\n\x0ehistory_length\x18\x03 \x01(\x05R\rhistoryLength\x12\x1a\n\x08\x62locking\x18\x04 \x01(\x08R\x08\x62locking\"\xf1\x01\n\x04Task\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12*\n\x06status\x18\x03 \x01(\x0b\x32\x12.a2a.v1.TaskStatusR\x06status\x12.\n\tartifacts\x18\x04 \x03(\x0b\x32\x10.a2a.v1.ArtifactR\tartifacts\x12)\n\x07history\x18\x05 \x03(\x0b\x32\x0f.a2a.v1.MessageR\x07history\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"\x99\x01\n\nTaskStatus\x12\'\n\x05state\x18\x01 \x01(\x0e\x32\x11.a2a.v1.TaskStateR\x05state\x12(\n\x06update\x18\x02 \x01(\x0b\x32\x0f.a2a.v1.MessageR\x07message\x12\x38\n\ttimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\"\xa9\x01\n\x04Part\x12\x14\n\x04text\x18\x01 \x01(\tH\x00R\x04text\x12&\n\x04\x66ile\x18\x02 \x01(\x0b\x32\x10.a2a.v1.FilePartH\x00R\x04\x66ile\x12&\n\x04\x64\x61ta\x18\x03 \x01(\x0b\x32\x10.a2a.v1.DataPartH\x00R\x04\x64\x61ta\x12\x33\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadataB\x06\n\x04part\"\x93\x01\n\x08\x46ilePart\x12$\n\rfile_with_uri\x18\x01 \x01(\tH\x00R\x0b\x66ileWithUri\x12(\n\x0f\x66ile_with_bytes\x18\x02 \x01(\x0cH\x00R\rfileWithBytes\x12\x1b\n\tmime_type\x18\x03 \x01(\tR\x08mimeType\x12\x12\n\x04name\x18\x04 \x01(\tR\x04nameB\x06\n\x04\x66ile\"7\n\x08\x44\x61taPart\x12+\n\x04\x64\x61ta\x18\x01 \x01(\x0b\x32\x17.google.protobuf.StructR\x04\x64\x61ta\"\xff\x01\n\x07Message\x12\x1d\n\nmessage_id\x18\x01 \x01(\tR\tmessageId\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12\x17\n\x07task_id\x18\x03 \x01(\tR\x06taskId\x12 \n\x04role\x18\x04 \x01(\x0e\x32\x0c.a2a.v1.RoleR\x04role\x12&\n\x07\x63ontent\x18\x05 \x03(\x0b\x32\x0c.a2a.v1.PartR\x07\x63ontent\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12\x1e\n\nextensions\x18\x07 \x03(\tR\nextensions\"\xda\x01\n\x08\x41rtifact\x12\x1f\n\x0b\x61rtifact_id\x18\x01 \x01(\tR\nartifactId\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x04 \x01(\tR\x0b\x64\x65scription\x12\"\n\x05parts\x18\x05 \x03(\x0b\x32\x0c.a2a.v1.PartR\x05parts\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12\x1e\n\nextensions\x18\x07 \x03(\tR\nextensions\"\xc6\x01\n\x15TaskStatusUpdateEvent\x12\x17\n\x07task_id\x18\x01 \x01(\tR\x06taskId\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12*\n\x06status\x18\x03 \x01(\x0b\x32\x12.a2a.v1.TaskStatusR\x06status\x12\x14\n\x05\x66inal\x18\x04 \x01(\x08R\x05\x66inal\x12\x33\n\x08metadata\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"\xeb\x01\n\x17TaskArtifactUpdateEvent\x12\x17\n\x07task_id\x18\x01 \x01(\tR\x06taskId\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12,\n\x08\x61rtifact\x18\x03 \x01(\x0b\x32\x10.a2a.v1.ArtifactR\x08\x61rtifact\x12\x16\n\x06\x61ppend\x18\x04 \x01(\x08R\x06\x61ppend\x12\x1d\n\nlast_chunk\x18\x05 \x01(\x08R\tlastChunk\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"\x94\x01\n\x16PushNotificationConfig\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x10\n\x03url\x18\x02 \x01(\tR\x03url\x12\x14\n\x05token\x18\x03 \x01(\tR\x05token\x12\x42\n\x0e\x61uthentication\x18\x04 \x01(\x0b\x32\x1a.a2a.v1.AuthenticationInfoR\x0e\x61uthentication\"P\n\x12\x41uthenticationInfo\x12\x18\n\x07schemes\x18\x01 \x03(\tR\x07schemes\x12 \n\x0b\x63redentials\x18\x02 \x01(\tR\x0b\x63redentials\"@\n\x0e\x41gentInterface\x12\x10\n\x03url\x18\x01 \x01(\tR\x03url\x12\x1c\n\ttransport\x18\x02 \x01(\tR\ttransport\"\xc8\x07\n\tAgentCard\x12)\n\x10protocol_version\x18\x10 \x01(\tR\x0fprotocolVersion\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x10\n\x03url\x18\x03 \x01(\tR\x03url\x12/\n\x13preferred_transport\x18\x0e \x01(\tR\x12preferredTransport\x12K\n\x15\x61\x64\x64itional_interfaces\x18\x0f \x03(\x0b\x32\x16.a2a.v1.AgentInterfaceR\x14\x61\x64\x64itionalInterfaces\x12\x31\n\x08provider\x18\x04 \x01(\x0b\x32\x15.a2a.v1.AgentProviderR\x08provider\x12\x18\n\x07version\x18\x05 \x01(\tR\x07version\x12+\n\x11\x64ocumentation_url\x18\x06 \x01(\tR\x10\x64ocumentationUrl\x12=\n\x0c\x63\x61pabilities\x18\x07 \x01(\x0b\x32\x19.a2a.v1.AgentCapabilitiesR\x0c\x63\x61pabilities\x12Q\n\x10security_schemes\x18\x08 \x03(\x0b\x32&.a2a.v1.AgentCard.SecuritySchemesEntryR\x0fsecuritySchemes\x12,\n\x08security\x18\t \x03(\x0b\x32\x10.a2a.v1.SecurityR\x08security\x12.\n\x13\x64\x65\x66\x61ult_input_modes\x18\n \x03(\tR\x11\x64\x65\x66\x61ultInputModes\x12\x30\n\x14\x64\x65\x66\x61ult_output_modes\x18\x0b \x03(\tR\x12\x64\x65\x66\x61ultOutputModes\x12*\n\x06skills\x18\x0c \x03(\x0b\x32\x12.a2a.v1.AgentSkillR\x06skills\x12O\n$supports_authenticated_extended_card\x18\r \x01(\x08R!supportsAuthenticatedExtendedCard\x12:\n\nsignatures\x18\x11 \x03(\x0b\x32\x1a.a2a.v1.AgentCardSignatureR\nsignatures\x12\x19\n\x08icon_url\x18\x12 \x01(\tR\x07iconUrl\x1aZ\n\x14SecuritySchemesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.a2a.v1.SecuritySchemeR\x05value:\x02\x38\x01\"E\n\rAgentProvider\x12\x10\n\x03url\x18\x01 \x01(\tR\x03url\x12\"\n\x0corganization\x18\x02 \x01(\tR\x0corganization\"\x98\x01\n\x11\x41gentCapabilities\x12\x1c\n\tstreaming\x18\x01 \x01(\x08R\tstreaming\x12-\n\x12push_notifications\x18\x02 \x01(\x08R\x11pushNotifications\x12\x36\n\nextensions\x18\x03 \x03(\x0b\x32\x16.a2a.v1.AgentExtensionR\nextensions\"\x91\x01\n\x0e\x41gentExtension\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x1a\n\x08required\x18\x03 \x01(\x08R\x08required\x12/\n\x06params\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\x06params\"\xf4\x01\n\nAgentSkill\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x03 \x01(\tR\x0b\x64\x65scription\x12\x12\n\x04tags\x18\x04 \x03(\tR\x04tags\x12\x1a\n\x08\x65xamples\x18\x05 \x03(\tR\x08\x65xamples\x12\x1f\n\x0binput_modes\x18\x06 \x03(\tR\ninputModes\x12!\n\x0coutput_modes\x18\x07 \x03(\tR\x0boutputModes\x12,\n\x08security\x18\x08 \x03(\x0b\x32\x10.a2a.v1.SecurityR\x08security\"\x8b\x01\n\x12\x41gentCardSignature\x12!\n\tprotected\x18\x01 \x01(\tB\x03\xe0\x41\x02R\tprotected\x12!\n\tsignature\x18\x02 \x01(\tB\x03\xe0\x41\x02R\tsignature\x12/\n\x06header\x18\x03 \x01(\x0b\x32\x17.google.protobuf.StructR\x06header\"\x8a\x01\n\x1aTaskPushNotificationConfig\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12X\n\x18push_notification_config\x18\x02 \x01(\x0b\x32\x1e.a2a.v1.PushNotificationConfigR\x16pushNotificationConfig\" \n\nStringList\x12\x12\n\x04list\x18\x01 \x03(\tR\x04list\"\x93\x01\n\x08Security\x12\x37\n\x07schemes\x18\x01 \x03(\x0b\x32\x1d.a2a.v1.Security.SchemesEntryR\x07schemes\x1aN\n\x0cSchemesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12(\n\x05value\x18\x02 \x01(\x0b\x32\x12.a2a.v1.StringListR\x05value:\x02\x38\x01\"\xe6\x03\n\x0eSecurityScheme\x12U\n\x17\x61pi_key_security_scheme\x18\x01 \x01(\x0b\x32\x1c.a2a.v1.APIKeySecuritySchemeH\x00R\x14\x61piKeySecurityScheme\x12[\n\x19http_auth_security_scheme\x18\x02 \x01(\x0b\x32\x1e.a2a.v1.HTTPAuthSecuritySchemeH\x00R\x16httpAuthSecurityScheme\x12T\n\x16oauth2_security_scheme\x18\x03 \x01(\x0b\x32\x1c.a2a.v1.OAuth2SecuritySchemeH\x00R\x14oauth2SecurityScheme\x12k\n\x1fopen_id_connect_security_scheme\x18\x04 \x01(\x0b\x32#.a2a.v1.OpenIdConnectSecuritySchemeH\x00R\x1bopenIdConnectSecurityScheme\x12S\n\x14mtls_security_scheme\x18\x05 \x01(\x0b\x32\x1f.a2a.v1.MutualTlsSecuritySchemeH\x00R\x12mtlsSecuritySchemeB\x08\n\x06scheme\"h\n\x14\x41PIKeySecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x1a\n\x08location\x18\x02 \x01(\tR\x08location\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\"w\n\x16HTTPAuthSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x16\n\x06scheme\x18\x02 \x01(\tR\x06scheme\x12#\n\rbearer_format\x18\x03 \x01(\tR\x0c\x62\x65\x61rerFormat\"\x92\x01\n\x14OAuth2SecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12(\n\x05\x66lows\x18\x02 \x01(\x0b\x32\x12.a2a.v1.OAuthFlowsR\x05\x66lows\x12.\n\x13oauth2_metadata_url\x18\x03 \x01(\tR\x11oauth2MetadataUrl\"n\n\x1bOpenIdConnectSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12-\n\x13open_id_connect_url\x18\x02 \x01(\tR\x10openIdConnectUrl\";\n\x17MutualTlsSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\"\xb0\x02\n\nOAuthFlows\x12S\n\x12\x61uthorization_code\x18\x01 \x01(\x0b\x32\".a2a.v1.AuthorizationCodeOAuthFlowH\x00R\x11\x61uthorizationCode\x12S\n\x12\x63lient_credentials\x18\x02 \x01(\x0b\x32\".a2a.v1.ClientCredentialsOAuthFlowH\x00R\x11\x63lientCredentials\x12\x37\n\x08implicit\x18\x03 \x01(\x0b\x32\x19.a2a.v1.ImplicitOAuthFlowH\x00R\x08implicit\x12\x37\n\x08password\x18\x04 \x01(\x0b\x32\x19.a2a.v1.PasswordOAuthFlowH\x00R\x08passwordB\x06\n\x04\x66low\"\x8a\x02\n\x1a\x41uthorizationCodeOAuthFlow\x12+\n\x11\x61uthorization_url\x18\x01 \x01(\tR\x10\x61uthorizationUrl\x12\x1b\n\ttoken_url\x18\x02 \x01(\tR\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x03 \x01(\tR\nrefreshUrl\x12\x46\n\x06scopes\x18\x04 \x03(\x0b\x32..a2a.v1.AuthorizationCodeOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xdd\x01\n\x1a\x43lientCredentialsOAuthFlow\x12\x1b\n\ttoken_url\x18\x01 \x01(\tR\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12\x46\n\x06scopes\x18\x03 \x03(\x0b\x32..a2a.v1.ClientCredentialsOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xdb\x01\n\x11ImplicitOAuthFlow\x12+\n\x11\x61uthorization_url\x18\x01 \x01(\tR\x10\x61uthorizationUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12=\n\x06scopes\x18\x03 \x03(\x0b\x32%.a2a.v1.ImplicitOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xcb\x01\n\x11PasswordOAuthFlow\x12\x1b\n\ttoken_url\x18\x01 \x01(\tR\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12=\n\x06scopes\x18\x03 \x03(\x0b\x32%.a2a.v1.PasswordOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xc1\x01\n\x12SendMessageRequest\x12.\n\x07request\x18\x01 \x01(\x0b\x32\x0f.a2a.v1.MessageB\x03\xe0\x41\x02R\x07message\x12\x46\n\rconfiguration\x18\x02 \x01(\x0b\x32 .a2a.v1.SendMessageConfigurationR\rconfiguration\x12\x33\n\x08metadata\x18\x03 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"P\n\x0eGetTaskRequest\x12\x17\n\x04name\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x04name\x12%\n\x0ehistory_length\x18\x02 \x01(\x05R\rhistoryLength\"\'\n\x11\x43\x61ncelTaskRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\":\n$GetTaskPushNotificationConfigRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"=\n\'DeleteTaskPushNotificationConfigRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"\xa9\x01\n\'CreateTaskPushNotificationConfigRequest\x12\x1b\n\x06parent\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x06parent\x12 \n\tconfig_id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x08\x63onfigId\x12?\n\x06\x63onfig\x18\x03 \x01(\x0b\x32\".a2a.v1.TaskPushNotificationConfigB\x03\xe0\x41\x02R\x06\x63onfig\"-\n\x17TaskSubscriptionRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"{\n%ListTaskPushNotificationConfigRequest\x12\x16\n\x06parent\x18\x01 \x01(\tR\x06parent\x12\x1b\n\tpage_size\x18\x02 \x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x03 \x01(\tR\tpageToken\"\x15\n\x13GetAgentCardRequest\"m\n\x13SendMessageResponse\x12\"\n\x04task\x18\x01 \x01(\x0b\x32\x0c.a2a.v1.TaskH\x00R\x04task\x12\'\n\x03msg\x18\x02 \x01(\x0b\x32\x0f.a2a.v1.MessageH\x00R\x07messageB\t\n\x07payload\"\xfa\x01\n\x0eStreamResponse\x12\"\n\x04task\x18\x01 \x01(\x0b\x32\x0c.a2a.v1.TaskH\x00R\x04task\x12\'\n\x03msg\x18\x02 \x01(\x0b\x32\x0f.a2a.v1.MessageH\x00R\x07message\x12\x44\n\rstatus_update\x18\x03 \x01(\x0b\x32\x1d.a2a.v1.TaskStatusUpdateEventH\x00R\x0cstatusUpdate\x12J\n\x0f\x61rtifact_update\x18\x04 \x01(\x0b\x32\x1f.a2a.v1.TaskArtifactUpdateEventH\x00R\x0e\x61rtifactUpdateB\t\n\x07payload\"\x8e\x01\n&ListTaskPushNotificationConfigResponse\x12<\n\x07\x63onfigs\x18\x01 \x03(\x0b\x32\".a2a.v1.TaskPushNotificationConfigR\x07\x63onfigs\x12&\n\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken*\xfa\x01\n\tTaskState\x12\x1a\n\x16TASK_STATE_UNSPECIFIED\x10\x00\x12\x18\n\x14TASK_STATE_SUBMITTED\x10\x01\x12\x16\n\x12TASK_STATE_WORKING\x10\x02\x12\x18\n\x14TASK_STATE_COMPLETED\x10\x03\x12\x15\n\x11TASK_STATE_FAILED\x10\x04\x12\x18\n\x14TASK_STATE_CANCELLED\x10\x05\x12\x1d\n\x19TASK_STATE_INPUT_REQUIRED\x10\x06\x12\x17\n\x13TASK_STATE_REJECTED\x10\x07\x12\x1c\n\x18TASK_STATE_AUTH_REQUIRED\x10\x08*;\n\x04Role\x12\x14\n\x10ROLE_UNSPECIFIED\x10\x00\x12\r\n\tROLE_USER\x10\x01\x12\x0e\n\nROLE_AGENT\x10\x02\x32\xbb\n\n\nA2AService\x12\x63\n\x0bSendMessage\x12\x1a.a2a.v1.SendMessageRequest\x1a\x1b.a2a.v1.SendMessageResponse\"\x1b\x82\xd3\xe4\x93\x02\x15\"\x10/v1/message:send:\x01*\x12k\n\x14SendStreamingMessage\x12\x1a.a2a.v1.SendMessageRequest\x1a\x16.a2a.v1.StreamResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\"\x12/v1/message:stream:\x01*0\x01\x12R\n\x07GetTask\x12\x16.a2a.v1.GetTaskRequest\x1a\x0c.a2a.v1.Task\"!\xda\x41\x04name\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/{name=tasks/*}\x12[\n\nCancelTask\x12\x19.a2a.v1.CancelTaskRequest\x1a\x0c.a2a.v1.Task\"$\x82\xd3\xe4\x93\x02\x1e\"\x19/v1/{name=tasks/*}:cancel:\x01*\x12s\n\x10TaskSubscription\x12\x1f.a2a.v1.TaskSubscriptionRequest\x1a\x16.a2a.v1.StreamResponse\"$\x82\xd3\xe4\x93\x02\x1e\x12\x1c/v1/{name=tasks/*}:subscribe0\x01\x12\xc5\x01\n CreateTaskPushNotificationConfig\x12/.a2a.v1.CreateTaskPushNotificationConfigRequest\x1a\".a2a.v1.TaskPushNotificationConfig\"L\xda\x41\rparent,config\x82\xd3\xe4\x93\x02\x36\",/v1/{parent=tasks/*/pushNotificationConfigs}:\x06\x63onfig\x12\xae\x01\n\x1dGetTaskPushNotificationConfig\x12,.a2a.v1.GetTaskPushNotificationConfigRequest\x1a\".a2a.v1.TaskPushNotificationConfig\";\xda\x41\x04name\x82\xd3\xe4\x93\x02.\x12,/v1/{name=tasks/*/pushNotificationConfigs/*}\x12\xbe\x01\n\x1eListTaskPushNotificationConfig\x12-.a2a.v1.ListTaskPushNotificationConfigRequest\x1a..a2a.v1.ListTaskPushNotificationConfigResponse\"=\xda\x41\x06parent\x82\xd3\xe4\x93\x02.\x12,/v1/{parent=tasks/*}/pushNotificationConfigs\x12P\n\x0cGetAgentCard\x12\x1b.a2a.v1.GetAgentCardRequest\x1a\x11.a2a.v1.AgentCard\"\x10\x82\xd3\xe4\x93\x02\n\x12\x08/v1/card\x12\xa8\x01\n DeleteTaskPushNotificationConfig\x12/.a2a.v1.DeleteTaskPushNotificationConfigRequest\x1a\x16.google.protobuf.Empty\";\xda\x41\x04name\x82\xd3\xe4\x93\x02.*,/v1/{name=tasks/*/pushNotificationConfigs/*}Bl\n\ncom.a2a.v1B\x0b\x41\x32\x61V03ProtoP\x01Z\x18google.golang.org/a2a/v1\xa2\x02\x03\x41XX\xaa\x02\x06\x41\x32\x61.V1\xca\x02\x06\x41\x32\x61\\V1\xe2\x02\x12\x41\x32\x61\\V1\\GPBMetadata\xea\x02\x07\x41\x32\x61::V1b\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'a2a_v0_3_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\ncom.a2a.v1B\013A2aV03ProtoP\001Z\030google.golang.org/a2a/v1\242\002\003AXX\252\002\006A2a.V1\312\002\006A2a\\V1\342\002\022A2a\\V1\\GPBMetadata\352\002\007A2a::V1'
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._loaded_options = None
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_options = b'8\001'
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['protected']._loaded_options = None
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['protected']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['signature']._loaded_options = None
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['signature']._serialized_options = b'\340A\002'
+  _globals['_SECURITY_SCHEMESENTRY']._loaded_options = None
+  _globals['_SECURITY_SCHEMESENTRY']._serialized_options = b'8\001'
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_SENDMESSAGEREQUEST'].fields_by_name['request']._loaded_options = None
+  _globals['_SENDMESSAGEREQUEST'].fields_by_name['request']._serialized_options = b'\340A\002'
+  _globals['_GETTASKREQUEST'].fields_by_name['name']._loaded_options = None
+  _globals['_GETTASKREQUEST'].fields_by_name['name']._serialized_options = b'\340A\002'
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['parent']._loaded_options = None
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['parent']._serialized_options = b'\340A\002'
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['config_id']._loaded_options = None
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['config_id']._serialized_options = b'\340A\002'
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['config']._loaded_options = None
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['config']._serialized_options = b'\340A\002'
+  _globals['_A2ASERVICE'].methods_by_name['SendMessage']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['SendMessage']._serialized_options = b'\202\323\344\223\002\025\"\020/v1/message:send:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['SendStreamingMessage']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['SendStreamingMessage']._serialized_options = b'\202\323\344\223\002\027\"\022/v1/message:stream:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['GetTask']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetTask']._serialized_options = b'\332A\004name\202\323\344\223\002\024\022\022/v1/{name=tasks/*}'
+  _globals['_A2ASERVICE'].methods_by_name['CancelTask']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['CancelTask']._serialized_options = b'\202\323\344\223\002\036\"\031/v1/{name=tasks/*}:cancel:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['TaskSubscription']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['TaskSubscription']._serialized_options = b'\202\323\344\223\002\036\022\034/v1/{name=tasks/*}:subscribe'
+  _globals['_A2ASERVICE'].methods_by_name['CreateTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['CreateTaskPushNotificationConfig']._serialized_options = b'\332A\rparent,config\202\323\344\223\0026\",/v1/{parent=tasks/*/pushNotificationConfigs}:\006config'
+  _globals['_A2ASERVICE'].methods_by_name['GetTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetTaskPushNotificationConfig']._serialized_options = b'\332A\004name\202\323\344\223\002.\022,/v1/{name=tasks/*/pushNotificationConfigs/*}'
+  _globals['_A2ASERVICE'].methods_by_name['ListTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['ListTaskPushNotificationConfig']._serialized_options = b'\332A\006parent\202\323\344\223\002.\022,/v1/{parent=tasks/*}/pushNotificationConfigs'
+  _globals['_A2ASERVICE'].methods_by_name['GetAgentCard']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetAgentCard']._serialized_options = b'\202\323\344\223\002\n\022\010/v1/card'
+  _globals['_A2ASERVICE'].methods_by_name['DeleteTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['DeleteTaskPushNotificationConfig']._serialized_options = b'\332A\004name\202\323\344\223\002.*,/v1/{name=tasks/*/pushNotificationConfigs/*}'
+  _globals['_TASKSTATE']._serialized_start=8071
+  _globals['_TASKSTATE']._serialized_end=8321
+  _globals['_ROLE']._serialized_start=8323
+  _globals['_ROLE']._serialized_end=8382
+  _globals['_SENDMESSAGECONFIGURATION']._serialized_start=207
+  _globals['_SENDMESSAGECONFIGURATION']._serialized_end=429
+  _globals['_TASK']._serialized_start=432
+  _globals['_TASK']._serialized_end=673
+  _globals['_TASKSTATUS']._serialized_start=676
+  _globals['_TASKSTATUS']._serialized_end=829
+  _globals['_PART']._serialized_start=832
+  _globals['_PART']._serialized_end=1001
+  _globals['_FILEPART']._serialized_start=1004
+  _globals['_FILEPART']._serialized_end=1151
+  _globals['_DATAPART']._serialized_start=1153
+  _globals['_DATAPART']._serialized_end=1208
+  _globals['_MESSAGE']._serialized_start=1211
+  _globals['_MESSAGE']._serialized_end=1466
+  _globals['_ARTIFACT']._serialized_start=1469
+  _globals['_ARTIFACT']._serialized_end=1687
+  _globals['_TASKSTATUSUPDATEEVENT']._serialized_start=1690
+  _globals['_TASKSTATUSUPDATEEVENT']._serialized_end=1888
+  _globals['_TASKARTIFACTUPDATEEVENT']._serialized_start=1891
+  _globals['_TASKARTIFACTUPDATEEVENT']._serialized_end=2126
+  _globals['_PUSHNOTIFICATIONCONFIG']._serialized_start=2129
+  _globals['_PUSHNOTIFICATIONCONFIG']._serialized_end=2277
+  _globals['_AUTHENTICATIONINFO']._serialized_start=2279
+  _globals['_AUTHENTICATIONINFO']._serialized_end=2359
+  _globals['_AGENTINTERFACE']._serialized_start=2361
+  _globals['_AGENTINTERFACE']._serialized_end=2425
+  _globals['_AGENTCARD']._serialized_start=2428
+  _globals['_AGENTCARD']._serialized_end=3396
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_start=3306
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_end=3396
+  _globals['_AGENTPROVIDER']._serialized_start=3398
+  _globals['_AGENTPROVIDER']._serialized_end=3467
+  _globals['_AGENTCAPABILITIES']._serialized_start=3470
+  _globals['_AGENTCAPABILITIES']._serialized_end=3622
+  _globals['_AGENTEXTENSION']._serialized_start=3625
+  _globals['_AGENTEXTENSION']._serialized_end=3770
+  _globals['_AGENTSKILL']._serialized_start=3773
+  _globals['_AGENTSKILL']._serialized_end=4017
+  _globals['_AGENTCARDSIGNATURE']._serialized_start=4020
+  _globals['_AGENTCARDSIGNATURE']._serialized_end=4159
+  _globals['_TASKPUSHNOTIFICATIONCONFIG']._serialized_start=4162
+  _globals['_TASKPUSHNOTIFICATIONCONFIG']._serialized_end=4300
+  _globals['_STRINGLIST']._serialized_start=4302
+  _globals['_STRINGLIST']._serialized_end=4334
+  _globals['_SECURITY']._serialized_start=4337
+  _globals['_SECURITY']._serialized_end=4484
+  _globals['_SECURITY_SCHEMESENTRY']._serialized_start=4406
+  _globals['_SECURITY_SCHEMESENTRY']._serialized_end=4484
+  _globals['_SECURITYSCHEME']._serialized_start=4487
+  _globals['_SECURITYSCHEME']._serialized_end=4973
+  _globals['_APIKEYSECURITYSCHEME']._serialized_start=4975
+  _globals['_APIKEYSECURITYSCHEME']._serialized_end=5079
+  _globals['_HTTPAUTHSECURITYSCHEME']._serialized_start=5081
+  _globals['_HTTPAUTHSECURITYSCHEME']._serialized_end=5200
+  _globals['_OAUTH2SECURITYSCHEME']._serialized_start=5203
+  _globals['_OAUTH2SECURITYSCHEME']._serialized_end=5349
+  _globals['_OPENIDCONNECTSECURITYSCHEME']._serialized_start=5351
+  _globals['_OPENIDCONNECTSECURITYSCHEME']._serialized_end=5461
+  _globals['_MUTUALTLSSECURITYSCHEME']._serialized_start=5463
+  _globals['_MUTUALTLSSECURITYSCHEME']._serialized_end=5522
+  _globals['_OAUTHFLOWS']._serialized_start=5525
+  _globals['_OAUTHFLOWS']._serialized_end=5829
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW']._serialized_start=5832
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW']._serialized_end=6098
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_start=6041
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_end=6098
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW']._serialized_start=6101
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW']._serialized_end=6322
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_start=6041
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_end=6098
+  _globals['_IMPLICITOAUTHFLOW']._serialized_start=6325
+  _globals['_IMPLICITOAUTHFLOW']._serialized_end=6544
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_start=6041
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_end=6098
+  _globals['_PASSWORDOAUTHFLOW']._serialized_start=6547
+  _globals['_PASSWORDOAUTHFLOW']._serialized_end=6750
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_start=6041
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_end=6098
+  _globals['_SENDMESSAGEREQUEST']._serialized_start=6753
+  _globals['_SENDMESSAGEREQUEST']._serialized_end=6946
+  _globals['_GETTASKREQUEST']._serialized_start=6948
+  _globals['_GETTASKREQUEST']._serialized_end=7028
+  _globals['_CANCELTASKREQUEST']._serialized_start=7030
+  _globals['_CANCELTASKREQUEST']._serialized_end=7069
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=7071
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=7129
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=7131
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=7192
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=7195
+  _globals['_CREATETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=7364
+  _globals['_TASKSUBSCRIPTIONREQUEST']._serialized_start=7366
+  _globals['_TASKSUBSCRIPTIONREQUEST']._serialized_end=7411
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=7413
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=7536
+  _globals['_GETAGENTCARDREQUEST']._serialized_start=7538
+  _globals['_GETAGENTCARDREQUEST']._serialized_end=7559
+  _globals['_SENDMESSAGERESPONSE']._serialized_start=7561
+  _globals['_SENDMESSAGERESPONSE']._serialized_end=7670
+  _globals['_STREAMRESPONSE']._serialized_start=7673
+  _globals['_STREAMRESPONSE']._serialized_end=7923
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGRESPONSE']._serialized_start=7926
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGRESPONSE']._serialized_end=8068
+  _globals['_A2ASERVICE']._serialized_start=8385
+  _globals['_A2ASERVICE']._serialized_end=9724
+# @@protoc_insertion_point(module_scope)
diff --git a/src/a2a/compat/v0_3/a2a_v0_3_pb2.pyi b/src/a2a/compat/v0_3/a2a_v0_3_pb2.pyi
new file mode 100644
index 000000000..06005e850
--- /dev/null
+++ b/src/a2a/compat/v0_3/a2a_v0_3_pb2.pyi
@@ -0,0 +1,574 @@
+import datetime
+
+from google.api import annotations_pb2 as _annotations_pb2
+from google.api import client_pb2 as _client_pb2
+from google.api import field_behavior_pb2 as _field_behavior_pb2
+from google.protobuf import empty_pb2 as _empty_pb2
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf import timestamp_pb2 as _timestamp_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class TaskState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    TASK_STATE_UNSPECIFIED: _ClassVar[TaskState]
+    TASK_STATE_SUBMITTED: _ClassVar[TaskState]
+    TASK_STATE_WORKING: _ClassVar[TaskState]
+    TASK_STATE_COMPLETED: _ClassVar[TaskState]
+    TASK_STATE_FAILED: _ClassVar[TaskState]
+    TASK_STATE_CANCELLED: _ClassVar[TaskState]
+    TASK_STATE_INPUT_REQUIRED: _ClassVar[TaskState]
+    TASK_STATE_REJECTED: _ClassVar[TaskState]
+    TASK_STATE_AUTH_REQUIRED: _ClassVar[TaskState]
+
+class Role(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    ROLE_UNSPECIFIED: _ClassVar[Role]
+    ROLE_USER: _ClassVar[Role]
+    ROLE_AGENT: _ClassVar[Role]
+TASK_STATE_UNSPECIFIED: TaskState
+TASK_STATE_SUBMITTED: TaskState
+TASK_STATE_WORKING: TaskState
+TASK_STATE_COMPLETED: TaskState
+TASK_STATE_FAILED: TaskState
+TASK_STATE_CANCELLED: TaskState
+TASK_STATE_INPUT_REQUIRED: TaskState
+TASK_STATE_REJECTED: TaskState
+TASK_STATE_AUTH_REQUIRED: TaskState
+ROLE_UNSPECIFIED: Role
+ROLE_USER: Role
+ROLE_AGENT: Role
+
+class SendMessageConfiguration(_message.Message):
+    __slots__ = ("accepted_output_modes", "push_notification", "history_length", "blocking")
+    ACCEPTED_OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    PUSH_NOTIFICATION_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    BLOCKING_FIELD_NUMBER: _ClassVar[int]
+    accepted_output_modes: _containers.RepeatedScalarFieldContainer[str]
+    push_notification: PushNotificationConfig
+    history_length: int
+    blocking: bool
+    def __init__(self, accepted_output_modes: _Optional[_Iterable[str]] = ..., push_notification: _Optional[_Union[PushNotificationConfig, _Mapping]] = ..., history_length: _Optional[int] = ..., blocking: _Optional[bool] = ...) -> None: ...
+
+class Task(_message.Message):
+    __slots__ = ("id", "context_id", "status", "artifacts", "history", "metadata")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACTS_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    context_id: str
+    status: TaskStatus
+    artifacts: _containers.RepeatedCompositeFieldContainer[Artifact]
+    history: _containers.RepeatedCompositeFieldContainer[Message]
+    metadata: _struct_pb2.Struct
+    def __init__(self, id: _Optional[str] = ..., context_id: _Optional[str] = ..., status: _Optional[_Union[TaskStatus, _Mapping]] = ..., artifacts: _Optional[_Iterable[_Union[Artifact, _Mapping]]] = ..., history: _Optional[_Iterable[_Union[Message, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskStatus(_message.Message):
+    __slots__ = ("state", "update", "timestamp")
+    STATE_FIELD_NUMBER: _ClassVar[int]
+    UPDATE_FIELD_NUMBER: _ClassVar[int]
+    TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
+    state: TaskState
+    update: Message
+    timestamp: _timestamp_pb2.Timestamp
+    def __init__(self, state: _Optional[_Union[TaskState, str]] = ..., update: _Optional[_Union[Message, _Mapping]] = ..., timestamp: _Optional[_Union[datetime.datetime, _timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ...
+
+class Part(_message.Message):
+    __slots__ = ("text", "file", "data", "metadata")
+    TEXT_FIELD_NUMBER: _ClassVar[int]
+    FILE_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    text: str
+    file: FilePart
+    data: DataPart
+    metadata: _struct_pb2.Struct
+    def __init__(self, text: _Optional[str] = ..., file: _Optional[_Union[FilePart, _Mapping]] = ..., data: _Optional[_Union[DataPart, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class FilePart(_message.Message):
+    __slots__ = ("file_with_uri", "file_with_bytes", "mime_type", "name")
+    FILE_WITH_URI_FIELD_NUMBER: _ClassVar[int]
+    FILE_WITH_BYTES_FIELD_NUMBER: _ClassVar[int]
+    MIME_TYPE_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    file_with_uri: str
+    file_with_bytes: bytes
+    mime_type: str
+    name: str
+    def __init__(self, file_with_uri: _Optional[str] = ..., file_with_bytes: _Optional[bytes] = ..., mime_type: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ...
+
+class DataPart(_message.Message):
+    __slots__ = ("data",)
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    data: _struct_pb2.Struct
+    def __init__(self, data: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class Message(_message.Message):
+    __slots__ = ("message_id", "context_id", "task_id", "role", "content", "metadata", "extensions")
+    MESSAGE_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    ROLE_FIELD_NUMBER: _ClassVar[int]
+    CONTENT_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    message_id: str
+    context_id: str
+    task_id: str
+    role: Role
+    content: _containers.RepeatedCompositeFieldContainer[Part]
+    metadata: _struct_pb2.Struct
+    extensions: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, message_id: _Optional[str] = ..., context_id: _Optional[str] = ..., task_id: _Optional[str] = ..., role: _Optional[_Union[Role, str]] = ..., content: _Optional[_Iterable[_Union[Part, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., extensions: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class Artifact(_message.Message):
+    __slots__ = ("artifact_id", "name", "description", "parts", "metadata", "extensions")
+    ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    PARTS_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    artifact_id: str
+    name: str
+    description: str
+    parts: _containers.RepeatedCompositeFieldContainer[Part]
+    metadata: _struct_pb2.Struct
+    extensions: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, artifact_id: _Optional[str] = ..., name: _Optional[str] = ..., description: _Optional[str] = ..., parts: _Optional[_Iterable[_Union[Part, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., extensions: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class TaskStatusUpdateEvent(_message.Message):
+    __slots__ = ("task_id", "context_id", "status", "final", "metadata")
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    FINAL_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    task_id: str
+    context_id: str
+    status: TaskStatus
+    final: bool
+    metadata: _struct_pb2.Struct
+    def __init__(self, task_id: _Optional[str] = ..., context_id: _Optional[str] = ..., status: _Optional[_Union[TaskStatus, _Mapping]] = ..., final: _Optional[bool] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskArtifactUpdateEvent(_message.Message):
+    __slots__ = ("task_id", "context_id", "artifact", "append", "last_chunk", "metadata")
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACT_FIELD_NUMBER: _ClassVar[int]
+    APPEND_FIELD_NUMBER: _ClassVar[int]
+    LAST_CHUNK_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    task_id: str
+    context_id: str
+    artifact: Artifact
+    append: bool
+    last_chunk: bool
+    metadata: _struct_pb2.Struct
+    def __init__(self, task_id: _Optional[str] = ..., context_id: _Optional[str] = ..., artifact: _Optional[_Union[Artifact, _Mapping]] = ..., append: _Optional[bool] = ..., last_chunk: _Optional[bool] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class PushNotificationConfig(_message.Message):
+    __slots__ = ("id", "url", "token", "authentication")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    URL_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_FIELD_NUMBER: _ClassVar[int]
+    AUTHENTICATION_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    url: str
+    token: str
+    authentication: AuthenticationInfo
+    def __init__(self, id: _Optional[str] = ..., url: _Optional[str] = ..., token: _Optional[str] = ..., authentication: _Optional[_Union[AuthenticationInfo, _Mapping]] = ...) -> None: ...
+
+class AuthenticationInfo(_message.Message):
+    __slots__ = ("schemes", "credentials")
+    SCHEMES_FIELD_NUMBER: _ClassVar[int]
+    CREDENTIALS_FIELD_NUMBER: _ClassVar[int]
+    schemes: _containers.RepeatedScalarFieldContainer[str]
+    credentials: str
+    def __init__(self, schemes: _Optional[_Iterable[str]] = ..., credentials: _Optional[str] = ...) -> None: ...
+
+class AgentInterface(_message.Message):
+    __slots__ = ("url", "transport")
+    URL_FIELD_NUMBER: _ClassVar[int]
+    TRANSPORT_FIELD_NUMBER: _ClassVar[int]
+    url: str
+    transport: str
+    def __init__(self, url: _Optional[str] = ..., transport: _Optional[str] = ...) -> None: ...
+
+class AgentCard(_message.Message):
+    __slots__ = ("protocol_version", "name", "description", "url", "preferred_transport", "additional_interfaces", "provider", "version", "documentation_url", "capabilities", "security_schemes", "security", "default_input_modes", "default_output_modes", "skills", "supports_authenticated_extended_card", "signatures", "icon_url")
+    class SecuritySchemesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: SecurityScheme
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[SecurityScheme, _Mapping]] = ...) -> None: ...
+    PROTOCOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    URL_FIELD_NUMBER: _ClassVar[int]
+    PREFERRED_TRANSPORT_FIELD_NUMBER: _ClassVar[int]
+    ADDITIONAL_INTERFACES_FIELD_NUMBER: _ClassVar[int]
+    PROVIDER_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    DOCUMENTATION_URL_FIELD_NUMBER: _ClassVar[int]
+    CAPABILITIES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_SCHEMES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_FIELD_NUMBER: _ClassVar[int]
+    DEFAULT_INPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    DEFAULT_OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    SKILLS_FIELD_NUMBER: _ClassVar[int]
+    SUPPORTS_AUTHENTICATED_EXTENDED_CARD_FIELD_NUMBER: _ClassVar[int]
+    SIGNATURES_FIELD_NUMBER: _ClassVar[int]
+    ICON_URL_FIELD_NUMBER: _ClassVar[int]
+    protocol_version: str
+    name: str
+    description: str
+    url: str
+    preferred_transport: str
+    additional_interfaces: _containers.RepeatedCompositeFieldContainer[AgentInterface]
+    provider: AgentProvider
+    version: str
+    documentation_url: str
+    capabilities: AgentCapabilities
+    security_schemes: _containers.MessageMap[str, SecurityScheme]
+    security: _containers.RepeatedCompositeFieldContainer[Security]
+    default_input_modes: _containers.RepeatedScalarFieldContainer[str]
+    default_output_modes: _containers.RepeatedScalarFieldContainer[str]
+    skills: _containers.RepeatedCompositeFieldContainer[AgentSkill]
+    supports_authenticated_extended_card: bool
+    signatures: _containers.RepeatedCompositeFieldContainer[AgentCardSignature]
+    icon_url: str
+    def __init__(self, protocol_version: _Optional[str] = ..., name: _Optional[str] = ..., description: _Optional[str] = ..., url: _Optional[str] = ..., preferred_transport: _Optional[str] = ..., additional_interfaces: _Optional[_Iterable[_Union[AgentInterface, _Mapping]]] = ..., provider: _Optional[_Union[AgentProvider, _Mapping]] = ..., version: _Optional[str] = ..., documentation_url: _Optional[str] = ..., capabilities: _Optional[_Union[AgentCapabilities, _Mapping]] = ..., security_schemes: _Optional[_Mapping[str, SecurityScheme]] = ..., security: _Optional[_Iterable[_Union[Security, _Mapping]]] = ..., default_input_modes: _Optional[_Iterable[str]] = ..., default_output_modes: _Optional[_Iterable[str]] = ..., skills: _Optional[_Iterable[_Union[AgentSkill, _Mapping]]] = ..., supports_authenticated_extended_card: _Optional[bool] = ..., signatures: _Optional[_Iterable[_Union[AgentCardSignature, _Mapping]]] = ..., icon_url: _Optional[str] = ...) -> None: ...
+
+class AgentProvider(_message.Message):
+    __slots__ = ("url", "organization")
+    URL_FIELD_NUMBER: _ClassVar[int]
+    ORGANIZATION_FIELD_NUMBER: _ClassVar[int]
+    url: str
+    organization: str
+    def __init__(self, url: _Optional[str] = ..., organization: _Optional[str] = ...) -> None: ...
+
+class AgentCapabilities(_message.Message):
+    __slots__ = ("streaming", "push_notifications", "extensions")
+    STREAMING_FIELD_NUMBER: _ClassVar[int]
+    PUSH_NOTIFICATIONS_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    streaming: bool
+    push_notifications: bool
+    extensions: _containers.RepeatedCompositeFieldContainer[AgentExtension]
+    def __init__(self, streaming: _Optional[bool] = ..., push_notifications: _Optional[bool] = ..., extensions: _Optional[_Iterable[_Union[AgentExtension, _Mapping]]] = ...) -> None: ...
+
+class AgentExtension(_message.Message):
+    __slots__ = ("uri", "description", "required", "params")
+    URI_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    REQUIRED_FIELD_NUMBER: _ClassVar[int]
+    PARAMS_FIELD_NUMBER: _ClassVar[int]
+    uri: str
+    description: str
+    required: bool
+    params: _struct_pb2.Struct
+    def __init__(self, uri: _Optional[str] = ..., description: _Optional[str] = ..., required: _Optional[bool] = ..., params: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class AgentSkill(_message.Message):
+    __slots__ = ("id", "name", "description", "tags", "examples", "input_modes", "output_modes", "security")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    TAGS_FIELD_NUMBER: _ClassVar[int]
+    EXAMPLES_FIELD_NUMBER: _ClassVar[int]
+    INPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    name: str
+    description: str
+    tags: _containers.RepeatedScalarFieldContainer[str]
+    examples: _containers.RepeatedScalarFieldContainer[str]
+    input_modes: _containers.RepeatedScalarFieldContainer[str]
+    output_modes: _containers.RepeatedScalarFieldContainer[str]
+    security: _containers.RepeatedCompositeFieldContainer[Security]
+    def __init__(self, id: _Optional[str] = ..., name: _Optional[str] = ..., description: _Optional[str] = ..., tags: _Optional[_Iterable[str]] = ..., examples: _Optional[_Iterable[str]] = ..., input_modes: _Optional[_Iterable[str]] = ..., output_modes: _Optional[_Iterable[str]] = ..., security: _Optional[_Iterable[_Union[Security, _Mapping]]] = ...) -> None: ...
+
+class AgentCardSignature(_message.Message):
+    __slots__ = ("protected", "signature", "header")
+    PROTECTED_FIELD_NUMBER: _ClassVar[int]
+    SIGNATURE_FIELD_NUMBER: _ClassVar[int]
+    HEADER_FIELD_NUMBER: _ClassVar[int]
+    protected: str
+    signature: str
+    header: _struct_pb2.Struct
+    def __init__(self, protected: _Optional[str] = ..., signature: _Optional[str] = ..., header: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskPushNotificationConfig(_message.Message):
+    __slots__ = ("name", "push_notification_config")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    PUSH_NOTIFICATION_CONFIG_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    push_notification_config: PushNotificationConfig
+    def __init__(self, name: _Optional[str] = ..., push_notification_config: _Optional[_Union[PushNotificationConfig, _Mapping]] = ...) -> None: ...
+
+class StringList(_message.Message):
+    __slots__ = ("list",)
+    LIST_FIELD_NUMBER: _ClassVar[int]
+    list: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, list: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class Security(_message.Message):
+    __slots__ = ("schemes",)
+    class SchemesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: StringList
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[StringList, _Mapping]] = ...) -> None: ...
+    SCHEMES_FIELD_NUMBER: _ClassVar[int]
+    schemes: _containers.MessageMap[str, StringList]
+    def __init__(self, schemes: _Optional[_Mapping[str, StringList]] = ...) -> None: ...
+
+class SecurityScheme(_message.Message):
+    __slots__ = ("api_key_security_scheme", "http_auth_security_scheme", "oauth2_security_scheme", "open_id_connect_security_scheme", "mtls_security_scheme")
+    API_KEY_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    HTTP_AUTH_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    OAUTH2_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    OPEN_ID_CONNECT_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    MTLS_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    api_key_security_scheme: APIKeySecurityScheme
+    http_auth_security_scheme: HTTPAuthSecurityScheme
+    oauth2_security_scheme: OAuth2SecurityScheme
+    open_id_connect_security_scheme: OpenIdConnectSecurityScheme
+    mtls_security_scheme: MutualTlsSecurityScheme
+    def __init__(self, api_key_security_scheme: _Optional[_Union[APIKeySecurityScheme, _Mapping]] = ..., http_auth_security_scheme: _Optional[_Union[HTTPAuthSecurityScheme, _Mapping]] = ..., oauth2_security_scheme: _Optional[_Union[OAuth2SecurityScheme, _Mapping]] = ..., open_id_connect_security_scheme: _Optional[_Union[OpenIdConnectSecurityScheme, _Mapping]] = ..., mtls_security_scheme: _Optional[_Union[MutualTlsSecurityScheme, _Mapping]] = ...) -> None: ...
+
+class APIKeySecurityScheme(_message.Message):
+    __slots__ = ("description", "location", "name")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    LOCATION_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    location: str
+    name: str
+    def __init__(self, description: _Optional[str] = ..., location: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ...
+
+class HTTPAuthSecurityScheme(_message.Message):
+    __slots__ = ("description", "scheme", "bearer_format")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    SCHEME_FIELD_NUMBER: _ClassVar[int]
+    BEARER_FORMAT_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    scheme: str
+    bearer_format: str
+    def __init__(self, description: _Optional[str] = ..., scheme: _Optional[str] = ..., bearer_format: _Optional[str] = ...) -> None: ...
+
+class OAuth2SecurityScheme(_message.Message):
+    __slots__ = ("description", "flows", "oauth2_metadata_url")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    FLOWS_FIELD_NUMBER: _ClassVar[int]
+    OAUTH2_METADATA_URL_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    flows: OAuthFlows
+    oauth2_metadata_url: str
+    def __init__(self, description: _Optional[str] = ..., flows: _Optional[_Union[OAuthFlows, _Mapping]] = ..., oauth2_metadata_url: _Optional[str] = ...) -> None: ...
+
+class OpenIdConnectSecurityScheme(_message.Message):
+    __slots__ = ("description", "open_id_connect_url")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    OPEN_ID_CONNECT_URL_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    open_id_connect_url: str
+    def __init__(self, description: _Optional[str] = ..., open_id_connect_url: _Optional[str] = ...) -> None: ...
+
+class MutualTlsSecurityScheme(_message.Message):
+    __slots__ = ("description",)
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    def __init__(self, description: _Optional[str] = ...) -> None: ...
+
+class OAuthFlows(_message.Message):
+    __slots__ = ("authorization_code", "client_credentials", "implicit", "password")
+    AUTHORIZATION_CODE_FIELD_NUMBER: _ClassVar[int]
+    CLIENT_CREDENTIALS_FIELD_NUMBER: _ClassVar[int]
+    IMPLICIT_FIELD_NUMBER: _ClassVar[int]
+    PASSWORD_FIELD_NUMBER: _ClassVar[int]
+    authorization_code: AuthorizationCodeOAuthFlow
+    client_credentials: ClientCredentialsOAuthFlow
+    implicit: ImplicitOAuthFlow
+    password: PasswordOAuthFlow
+    def __init__(self, authorization_code: _Optional[_Union[AuthorizationCodeOAuthFlow, _Mapping]] = ..., client_credentials: _Optional[_Union[ClientCredentialsOAuthFlow, _Mapping]] = ..., implicit: _Optional[_Union[ImplicitOAuthFlow, _Mapping]] = ..., password: _Optional[_Union[PasswordOAuthFlow, _Mapping]] = ...) -> None: ...
+
+class AuthorizationCodeOAuthFlow(_message.Message):
+    __slots__ = ("authorization_url", "token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    authorization_url: str
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, authorization_url: _Optional[str] = ..., token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class ClientCredentialsOAuthFlow(_message.Message):
+    __slots__ = ("token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class ImplicitOAuthFlow(_message.Message):
+    __slots__ = ("authorization_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    authorization_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, authorization_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class PasswordOAuthFlow(_message.Message):
+    __slots__ = ("token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class SendMessageRequest(_message.Message):
+    __slots__ = ("request", "configuration", "metadata")
+    REQUEST_FIELD_NUMBER: _ClassVar[int]
+    CONFIGURATION_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    request: Message
+    configuration: SendMessageConfiguration
+    metadata: _struct_pb2.Struct
+    def __init__(self, request: _Optional[_Union[Message, _Mapping]] = ..., configuration: _Optional[_Union[SendMessageConfiguration, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class GetTaskRequest(_message.Message):
+    __slots__ = ("name", "history_length")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    history_length: int
+    def __init__(self, name: _Optional[str] = ..., history_length: _Optional[int] = ...) -> None: ...
+
+class CancelTaskRequest(_message.Message):
+    __slots__ = ("name",)
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    def __init__(self, name: _Optional[str] = ...) -> None: ...
+
+class GetTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("name",)
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    def __init__(self, name: _Optional[str] = ...) -> None: ...
+
+class DeleteTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("name",)
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    def __init__(self, name: _Optional[str] = ...) -> None: ...
+
+class CreateTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("parent", "config_id", "config")
+    PARENT_FIELD_NUMBER: _ClassVar[int]
+    CONFIG_ID_FIELD_NUMBER: _ClassVar[int]
+    CONFIG_FIELD_NUMBER: _ClassVar[int]
+    parent: str
+    config_id: str
+    config: TaskPushNotificationConfig
+    def __init__(self, parent: _Optional[str] = ..., config_id: _Optional[str] = ..., config: _Optional[_Union[TaskPushNotificationConfig, _Mapping]] = ...) -> None: ...
+
+class TaskSubscriptionRequest(_message.Message):
+    __slots__ = ("name",)
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    def __init__(self, name: _Optional[str] = ...) -> None: ...
+
+class ListTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("parent", "page_size", "page_token")
+    PARENT_FIELD_NUMBER: _ClassVar[int]
+    PAGE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    parent: str
+    page_size: int
+    page_token: str
+    def __init__(self, parent: _Optional[str] = ..., page_size: _Optional[int] = ..., page_token: _Optional[str] = ...) -> None: ...
+
+class GetAgentCardRequest(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class SendMessageResponse(_message.Message):
+    __slots__ = ("task", "msg")
+    TASK_FIELD_NUMBER: _ClassVar[int]
+    MSG_FIELD_NUMBER: _ClassVar[int]
+    task: Task
+    msg: Message
+    def __init__(self, task: _Optional[_Union[Task, _Mapping]] = ..., msg: _Optional[_Union[Message, _Mapping]] = ...) -> None: ...
+
+class StreamResponse(_message.Message):
+    __slots__ = ("task", "msg", "status_update", "artifact_update")
+    TASK_FIELD_NUMBER: _ClassVar[int]
+    MSG_FIELD_NUMBER: _ClassVar[int]
+    STATUS_UPDATE_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACT_UPDATE_FIELD_NUMBER: _ClassVar[int]
+    task: Task
+    msg: Message
+    status_update: TaskStatusUpdateEvent
+    artifact_update: TaskArtifactUpdateEvent
+    def __init__(self, task: _Optional[_Union[Task, _Mapping]] = ..., msg: _Optional[_Union[Message, _Mapping]] = ..., status_update: _Optional[_Union[TaskStatusUpdateEvent, _Mapping]] = ..., artifact_update: _Optional[_Union[TaskArtifactUpdateEvent, _Mapping]] = ...) -> None: ...
+
+class ListTaskPushNotificationConfigResponse(_message.Message):
+    __slots__ = ("configs", "next_page_token")
+    CONFIGS_FIELD_NUMBER: _ClassVar[int]
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    configs: _containers.RepeatedCompositeFieldContainer[TaskPushNotificationConfig]
+    next_page_token: str
+    def __init__(self, configs: _Optional[_Iterable[_Union[TaskPushNotificationConfig, _Mapping]]] = ..., next_page_token: _Optional[str] = ...) -> None: ...
diff --git a/src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py b/src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py
new file mode 100644
index 000000000..3bbd4dec7
--- /dev/null
+++ b/src/a2a/compat/v0_3/a2a_v0_3_pb2_grpc.py
@@ -0,0 +1,511 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from . import a2a_v0_3_pb2 as a2a__v0__3__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+
+
+class A2AServiceStub(object):
+    """A2AService defines the gRPC version of the A2A protocol. This has a slightly
+    different shape than the JSONRPC version to better conform to AIP-127,
+    where appropriate. The nouns are AgentCard, Message, Task and
+    TaskPushNotificationConfig.
+    - Messages are not a standard resource so there is no get/delete/update/list
+    interface, only a send and stream custom methods.
+    - Tasks have a get interface and custom cancel and subscribe methods.
+    - TaskPushNotificationConfig are a resource whose parent is a task.
+    They have get, list and create methods.
+    - AgentCard is a static resource with only a get method.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SendMessage = channel.unary_unary(
+                '/a2a.v1.A2AService/SendMessage',
+                request_serializer=a2a__v0__3__pb2.SendMessageRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.SendMessageResponse.FromString,
+                _registered_method=True)
+        self.SendStreamingMessage = channel.unary_stream(
+                '/a2a.v1.A2AService/SendStreamingMessage',
+                request_serializer=a2a__v0__3__pb2.SendMessageRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.StreamResponse.FromString,
+                _registered_method=True)
+        self.GetTask = channel.unary_unary(
+                '/a2a.v1.A2AService/GetTask',
+                request_serializer=a2a__v0__3__pb2.GetTaskRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.Task.FromString,
+                _registered_method=True)
+        self.CancelTask = channel.unary_unary(
+                '/a2a.v1.A2AService/CancelTask',
+                request_serializer=a2a__v0__3__pb2.CancelTaskRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.Task.FromString,
+                _registered_method=True)
+        self.TaskSubscription = channel.unary_stream(
+                '/a2a.v1.A2AService/TaskSubscription',
+                request_serializer=a2a__v0__3__pb2.TaskSubscriptionRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.StreamResponse.FromString,
+                _registered_method=True)
+        self.CreateTaskPushNotificationConfig = channel.unary_unary(
+                '/a2a.v1.A2AService/CreateTaskPushNotificationConfig',
+                request_serializer=a2a__v0__3__pb2.CreateTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.TaskPushNotificationConfig.FromString,
+                _registered_method=True)
+        self.GetTaskPushNotificationConfig = channel.unary_unary(
+                '/a2a.v1.A2AService/GetTaskPushNotificationConfig',
+                request_serializer=a2a__v0__3__pb2.GetTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.TaskPushNotificationConfig.FromString,
+                _registered_method=True)
+        self.ListTaskPushNotificationConfig = channel.unary_unary(
+                '/a2a.v1.A2AService/ListTaskPushNotificationConfig',
+                request_serializer=a2a__v0__3__pb2.ListTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.ListTaskPushNotificationConfigResponse.FromString,
+                _registered_method=True)
+        self.GetAgentCard = channel.unary_unary(
+                '/a2a.v1.A2AService/GetAgentCard',
+                request_serializer=a2a__v0__3__pb2.GetAgentCardRequest.SerializeToString,
+                response_deserializer=a2a__v0__3__pb2.AgentCard.FromString,
+                _registered_method=True)
+        self.DeleteTaskPushNotificationConfig = channel.unary_unary(
+                '/a2a.v1.A2AService/DeleteTaskPushNotificationConfig',
+                request_serializer=a2a__v0__3__pb2.DeleteTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+
+
+class A2AServiceServicer(object):
+    """A2AService defines the gRPC version of the A2A protocol. This has a slightly
+    different shape than the JSONRPC version to better conform to AIP-127,
+    where appropriate. The nouns are AgentCard, Message, Task and
+    TaskPushNotificationConfig.
+    - Messages are not a standard resource so there is no get/delete/update/list
+    interface, only a send and stream custom methods.
+    - Tasks have a get interface and custom cancel and subscribe methods.
+    - TaskPushNotificationConfig are a resource whose parent is a task.
+    They have get, list and create methods.
+    - AgentCard is a static resource with only a get method.
+    """
+
+    def SendMessage(self, request, context):
+        """Send a message to the agent. This is a blocking call that will return the
+        task once it is completed, or a LRO if requested.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SendStreamingMessage(self, request, context):
+        """SendStreamingMessage is a streaming call that will return a stream of
+        task update events until the Task is in an interrupted or terminal state.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTask(self, request, context):
+        """Get the current state of a task from the agent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def CancelTask(self, request, context):
+        """Cancel a task from the agent. If supported one should expect no
+        more task updates for the task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TaskSubscription(self, request, context):
+        """TaskSubscription is a streaming call that will return a stream of task
+        update events. This attaches the stream to an existing in process task.
+        If the task is complete the stream will return the completed task (like
+        GetTask) and close the stream.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def CreateTaskPushNotificationConfig(self, request, context):
+        """Set a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTaskPushNotificationConfig(self, request, context):
+        """Get a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTaskPushNotificationConfig(self, request, context):
+        """Get a list of push notifications configured for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetAgentCard(self, request, context):
+        """GetAgentCard returns the agent card for the agent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeleteTaskPushNotificationConfig(self, request, context):
+        """Delete a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_A2AServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SendMessage': grpc.unary_unary_rpc_method_handler(
+                    servicer.SendMessage,
+                    request_deserializer=a2a__v0__3__pb2.SendMessageRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.SendMessageResponse.SerializeToString,
+            ),
+            'SendStreamingMessage': grpc.unary_stream_rpc_method_handler(
+                    servicer.SendStreamingMessage,
+                    request_deserializer=a2a__v0__3__pb2.SendMessageRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.StreamResponse.SerializeToString,
+            ),
+            'GetTask': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTask,
+                    request_deserializer=a2a__v0__3__pb2.GetTaskRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.Task.SerializeToString,
+            ),
+            'CancelTask': grpc.unary_unary_rpc_method_handler(
+                    servicer.CancelTask,
+                    request_deserializer=a2a__v0__3__pb2.CancelTaskRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.Task.SerializeToString,
+            ),
+            'TaskSubscription': grpc.unary_stream_rpc_method_handler(
+                    servicer.TaskSubscription,
+                    request_deserializer=a2a__v0__3__pb2.TaskSubscriptionRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.StreamResponse.SerializeToString,
+            ),
+            'CreateTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.CreateTaskPushNotificationConfig,
+                    request_deserializer=a2a__v0__3__pb2.CreateTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.TaskPushNotificationConfig.SerializeToString,
+            ),
+            'GetTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTaskPushNotificationConfig,
+                    request_deserializer=a2a__v0__3__pb2.GetTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.TaskPushNotificationConfig.SerializeToString,
+            ),
+            'ListTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTaskPushNotificationConfig,
+                    request_deserializer=a2a__v0__3__pb2.ListTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.ListTaskPushNotificationConfigResponse.SerializeToString,
+            ),
+            'GetAgentCard': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetAgentCard,
+                    request_deserializer=a2a__v0__3__pb2.GetAgentCardRequest.FromString,
+                    response_serializer=a2a__v0__3__pb2.AgentCard.SerializeToString,
+            ),
+            'DeleteTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeleteTaskPushNotificationConfig,
+                    request_deserializer=a2a__v0__3__pb2.DeleteTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'a2a.v1.A2AService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('a2a.v1.A2AService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class A2AService(object):
+    """A2AService defines the gRPC version of the A2A protocol. This has a slightly
+    different shape than the JSONRPC version to better conform to AIP-127,
+    where appropriate. The nouns are AgentCard, Message, Task and
+    TaskPushNotificationConfig.
+    - Messages are not a standard resource so there is no get/delete/update/list
+    interface, only a send and stream custom methods.
+    - Tasks have a get interface and custom cancel and subscribe methods.
+    - TaskPushNotificationConfig are a resource whose parent is a task.
+    They have get, list and create methods.
+    - AgentCard is a static resource with only a get method.
+    """
+
+    @staticmethod
+    def SendMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/SendMessage',
+            a2a__v0__3__pb2.SendMessageRequest.SerializeToString,
+            a2a__v0__3__pb2.SendMessageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SendStreamingMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/a2a.v1.A2AService/SendStreamingMessage',
+            a2a__v0__3__pb2.SendMessageRequest.SerializeToString,
+            a2a__v0__3__pb2.StreamResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetTask(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/GetTask',
+            a2a__v0__3__pb2.GetTaskRequest.SerializeToString,
+            a2a__v0__3__pb2.Task.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def CancelTask(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/CancelTask',
+            a2a__v0__3__pb2.CancelTaskRequest.SerializeToString,
+            a2a__v0__3__pb2.Task.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def TaskSubscription(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/a2a.v1.A2AService/TaskSubscription',
+            a2a__v0__3__pb2.TaskSubscriptionRequest.SerializeToString,
+            a2a__v0__3__pb2.StreamResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def CreateTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/CreateTaskPushNotificationConfig',
+            a2a__v0__3__pb2.CreateTaskPushNotificationConfigRequest.SerializeToString,
+            a2a__v0__3__pb2.TaskPushNotificationConfig.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/GetTaskPushNotificationConfig',
+            a2a__v0__3__pb2.GetTaskPushNotificationConfigRequest.SerializeToString,
+            a2a__v0__3__pb2.TaskPushNotificationConfig.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/ListTaskPushNotificationConfig',
+            a2a__v0__3__pb2.ListTaskPushNotificationConfigRequest.SerializeToString,
+            a2a__v0__3__pb2.ListTaskPushNotificationConfigResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetAgentCard(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/GetAgentCard',
+            a2a__v0__3__pb2.GetAgentCardRequest.SerializeToString,
+            a2a__v0__3__pb2.AgentCard.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def DeleteTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/a2a.v1.A2AService/DeleteTaskPushNotificationConfig',
+            a2a__v0__3__pb2.DeleteTaskPushNotificationConfigRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
diff --git a/src/a2a/compat/v0_3/buf.lock b/src/a2a/compat/v0_3/buf.lock
new file mode 100644
index 000000000..5df8acde6
--- /dev/null
+++ b/src/a2a/compat/v0_3/buf.lock
@@ -0,0 +1,6 @@
+# Generated by buf. DO NOT EDIT.
+version: v2
+deps:
+  - name: buf.build/googleapis/googleapis
+    commit: 004180b77378443887d3b55cabc00384
+    digest: b5:e8f475fe3330f31f5fd86ac689093bcd274e19611a09db91f41d637cb9197881ce89882b94d13a58738e53c91c6e4bae7dc1feba85f590164c975a89e25115dc
diff --git a/src/a2a/compat/v0_3/buf.yaml b/src/a2a/compat/v0_3/buf.yaml
new file mode 100644
index 000000000..8d304d427
--- /dev/null
+++ b/src/a2a/compat/v0_3/buf.yaml
@@ -0,0 +1,3 @@
+version: v2
+deps:
+  - buf.build/googleapis/googleapis
diff --git a/src/a2a/compat/v0_3/context_builders.py b/src/a2a/compat/v0_3/context_builders.py
new file mode 100644
index 000000000..1874853f5
--- /dev/null
+++ b/src/a2a/compat/v0_3/context_builders.py
@@ -0,0 +1,75 @@
+"""Context builders that add v0.3 backwards-compatibility for extensions.
+
+The current spec uses ``A2A-Extensions`` (RFC 6648, no ``X-`` prefix). v0.3
+clients still send the old ``X-A2A-Extensions`` name, so the v0.3 compat
+adapters wrap the default builders with these classes to recognize both names.
+"""
+
+from typing import TYPE_CHECKING
+
+from a2a.compat.v0_3.extension_headers import LEGACY_HTTP_EXTENSION_HEADER
+from a2a.extensions.common import get_requested_extensions
+from a2a.server.context import ServerCallContext
+
+
+if TYPE_CHECKING:
+    import grpc
+
+    from starlette.requests import Request
+
+    from a2a.server.request_handlers.grpc_handler import (
+        GrpcServerCallContextBuilder,
+    )
+    from a2a.server.routes.common import ServerCallContextBuilder
+
+
+def _get_legacy_grpc_extensions(
+    context: 'grpc.aio.ServicerContext',
+) -> list[str]:
+    md = context.invocation_metadata()
+    if md is None:
+        return []
+    lower_key = LEGACY_HTTP_EXTENSION_HEADER.lower()
+    return [
+        e if isinstance(e, str) else e.decode('utf-8')
+        for k, e in md
+        if k.lower() == lower_key
+    ]
+
+
+class V03ServerCallContextBuilder:
+    """Wraps a ServerCallContextBuilder to also accept the legacy header.
+
+    Recognizes the v0.3 ``X-A2A-Extensions`` HTTP header in addition to the
+    spec ``A2A-Extensions``.
+    """
+
+    def __init__(self, inner: 'ServerCallContextBuilder') -> None:
+        self._inner = inner
+
+    def build(self, request: 'Request') -> ServerCallContext:
+        """Builds a ServerCallContext, merging legacy extension headers."""
+        context = self._inner.build(request)
+        context.requested_extensions |= get_requested_extensions(
+            request.headers.getlist(LEGACY_HTTP_EXTENSION_HEADER)
+        )
+        return context
+
+
+class V03GrpcServerCallContextBuilder:
+    """Wraps a GrpcServerCallContextBuilder to also accept the legacy metadata.
+
+    Recognizes the v0.3 ``X-A2A-Extensions`` gRPC metadata key in addition to
+    the spec ``A2A-Extensions``.
+    """
+
+    def __init__(self, inner: 'GrpcServerCallContextBuilder') -> None:
+        self._inner = inner
+
+    def build(self, context: 'grpc.aio.ServicerContext') -> ServerCallContext:
+        """Builds a ServerCallContext, merging legacy extension metadata."""
+        server_context = self._inner.build(context)
+        server_context.requested_extensions |= get_requested_extensions(
+            _get_legacy_grpc_extensions(context)
+        )
+        return server_context
diff --git a/src/a2a/compat/v0_3/conversions.py b/src/a2a/compat/v0_3/conversions.py
new file mode 100644
index 000000000..c6e847d30
--- /dev/null
+++ b/src/a2a/compat/v0_3/conversions.py
@@ -0,0 +1,1377 @@
+import base64
+
+from typing import Any
+
+from google.protobuf.json_format import MessageToDict, ParseDict
+
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.versions import is_legacy_version
+from a2a.types import a2a_pb2 as pb2_v10
+from a2a.utils import constants, errors
+
+
+_COMPAT_TO_CORE_TASK_STATE: dict[types_v03.TaskState, Any] = {
+    types_v03.TaskState.unknown: pb2_v10.TaskState.TASK_STATE_UNSPECIFIED,
+    types_v03.TaskState.submitted: pb2_v10.TaskState.TASK_STATE_SUBMITTED,
+    types_v03.TaskState.working: pb2_v10.TaskState.TASK_STATE_WORKING,
+    types_v03.TaskState.completed: pb2_v10.TaskState.TASK_STATE_COMPLETED,
+    types_v03.TaskState.failed: pb2_v10.TaskState.TASK_STATE_FAILED,
+    types_v03.TaskState.canceled: pb2_v10.TaskState.TASK_STATE_CANCELED,
+    types_v03.TaskState.input_required: pb2_v10.TaskState.TASK_STATE_INPUT_REQUIRED,
+    types_v03.TaskState.rejected: pb2_v10.TaskState.TASK_STATE_REJECTED,
+    types_v03.TaskState.auth_required: pb2_v10.TaskState.TASK_STATE_AUTH_REQUIRED,
+}
+
+_CORE_TO_COMPAT_TASK_STATE: dict[Any, types_v03.TaskState] = {
+    v: k for k, v in _COMPAT_TO_CORE_TASK_STATE.items()
+}
+
+
+def to_core_part(compat_part: types_v03.Part) -> pb2_v10.Part:  # noqa: PLR0912
+    """Converts a v0.3 Part (Pydantic model) to a v1.0 core Part (Protobuf object)."""
+    core_part = pb2_v10.Part()
+    root = compat_part.root
+
+    if isinstance(root, types_v03.TextPart):
+        core_part.text = root.text
+        if root.metadata is not None:
+            ParseDict(root.metadata, core_part.metadata)
+
+    elif isinstance(root, types_v03.DataPart):
+        if root.metadata is None:
+            data_part_compat = False
+        else:
+            meta = dict(root.metadata)
+            data_part_compat = meta.pop('data_part_compat', False)
+            if meta:
+                ParseDict(meta, core_part.metadata)
+
+        if data_part_compat:
+            val = root.data['value']
+            ParseDict(val, core_part.data)
+        else:
+            ParseDict(root.data, core_part.data.struct_value)
+
+    elif isinstance(root, types_v03.FilePart):
+        if isinstance(root.file, types_v03.FileWithBytes):
+            core_part.raw = base64.b64decode(root.file.bytes)
+            if root.file.mime_type:
+                core_part.media_type = root.file.mime_type
+            if root.file.name:
+                core_part.filename = root.file.name
+        elif isinstance(root.file, types_v03.FileWithUri):
+            core_part.url = root.file.uri
+            if root.file.mime_type:
+                core_part.media_type = root.file.mime_type
+            if root.file.name:
+                core_part.filename = root.file.name
+
+        if root.metadata is not None:
+            ParseDict(root.metadata, core_part.metadata)
+
+    return core_part
+
+
+def to_compat_part(core_part: pb2_v10.Part) -> types_v03.Part:
+    """Converts a v1.0 core Part (Protobuf object) to a v0.3 Part (Pydantic model)."""
+    which = core_part.WhichOneof('content')
+    metadata = (
+        MessageToDict(core_part.metadata)
+        if core_part.HasField('metadata')
+        else None
+    )
+
+    if which == 'text':
+        return types_v03.Part(
+            root=types_v03.TextPart(text=core_part.text, metadata=metadata)
+        )
+
+    if which == 'data':
+        # core_part.data is a google.protobuf.Value. It can be converted to dict.
+        data_dict = MessageToDict(core_part.data)
+        if not isinstance(data_dict, dict):
+            data_dict = {'value': data_dict}
+            metadata = metadata or {}
+            metadata['data_part_compat'] = True
+
+        return types_v03.Part(
+            root=types_v03.DataPart(data=data_dict, metadata=metadata)
+        )
+
+    if which in ('raw', 'url'):
+        media_type = core_part.media_type if core_part.media_type else None
+        filename = core_part.filename if core_part.filename else None
+
+        if which == 'raw':
+            b64 = base64.b64encode(core_part.raw).decode('utf-8')
+            file_obj_bytes = types_v03.FileWithBytes(
+                bytes=b64, mime_type=media_type, name=filename
+            )
+            return types_v03.Part(
+                root=types_v03.FilePart(file=file_obj_bytes, metadata=metadata)
+            )
+        file_obj_uri = types_v03.FileWithUri(
+            uri=core_part.url, mime_type=media_type, name=filename
+        )
+        return types_v03.Part(
+            root=types_v03.FilePart(file=file_obj_uri, metadata=metadata)
+        )
+
+    raise ValueError(f'Unknown part content type: {which}')
+
+
+def to_core_message(compat_msg: types_v03.Message) -> pb2_v10.Message:
+    """Convert message to v1.0 core type."""
+    core_msg = pb2_v10.Message(
+        message_id=compat_msg.message_id,
+        context_id=compat_msg.context_id or '',
+        task_id=compat_msg.task_id or '',
+    )
+    if compat_msg.reference_task_ids:
+        core_msg.reference_task_ids.extend(compat_msg.reference_task_ids)
+
+    if compat_msg.role == types_v03.Role.user:
+        core_msg.role = pb2_v10.Role.ROLE_USER
+    elif compat_msg.role == types_v03.Role.agent:
+        core_msg.role = pb2_v10.Role.ROLE_AGENT
+
+    if compat_msg.metadata:
+        ParseDict(compat_msg.metadata, core_msg.metadata)
+
+    if compat_msg.extensions:
+        core_msg.extensions.extend(compat_msg.extensions)
+
+    for p in compat_msg.parts:
+        core_msg.parts.append(to_core_part(p))
+    return core_msg
+
+
+def to_compat_message(core_msg: pb2_v10.Message) -> types_v03.Message:
+    """Convert message to v0.3 compat type."""
+    role = (
+        types_v03.Role.user
+        if core_msg.role == pb2_v10.Role.ROLE_USER
+        else types_v03.Role.agent
+    )
+    return types_v03.Message(
+        message_id=core_msg.message_id,
+        role=role,
+        context_id=core_msg.context_id or None,
+        task_id=core_msg.task_id or None,
+        reference_task_ids=list(core_msg.reference_task_ids)
+        if core_msg.reference_task_ids
+        else None,
+        metadata=MessageToDict(core_msg.metadata)
+        if core_msg.metadata
+        else None,
+        extensions=list(core_msg.extensions) if core_msg.extensions else None,
+        parts=[to_compat_part(p) for p in core_msg.parts],
+    )
+
+
+def to_core_task_status(
+    compat_status: types_v03.TaskStatus,
+) -> pb2_v10.TaskStatus:
+    """Convert task status to v1.0 core type."""
+    core_status = pb2_v10.TaskStatus()
+    if compat_status.state:
+        core_status.state = _COMPAT_TO_CORE_TASK_STATE.get(
+            compat_status.state, pb2_v10.TaskState.TASK_STATE_UNSPECIFIED
+        )
+
+    if compat_status.message:
+        core_status.message.CopyFrom(to_core_message(compat_status.message))
+    if compat_status.timestamp:
+        core_status.timestamp.FromJsonString(
+            str(compat_status.timestamp).replace('+00:00', 'Z')
+        )
+    return core_status
+
+
+def to_compat_task_status(
+    core_status: pb2_v10.TaskStatus,
+) -> types_v03.TaskStatus:
+    """Convert task status to v0.3 compat type."""
+    state_enum = _CORE_TO_COMPAT_TASK_STATE.get(
+        core_status.state, types_v03.TaskState.unknown
+    )
+
+    update = (
+        to_compat_message(core_status.message)
+        if core_status.HasField('message')
+        else None
+    )
+    ts = (
+        core_status.timestamp.ToJsonString()
+        if core_status.HasField('timestamp')
+        else None
+    )
+
+    return types_v03.TaskStatus(state=state_enum, message=update, timestamp=ts)
+
+
+def to_core_task(compat_task: types_v03.Task) -> pb2_v10.Task:
+    """Convert task to v1.0 core type."""
+    core_task = pb2_v10.Task(
+        id=compat_task.id,
+        context_id=compat_task.context_id,
+    )
+    if compat_task.status:
+        core_task.status.CopyFrom(to_core_task_status(compat_task.status))
+    if compat_task.history:
+        for m in compat_task.history:
+            core_task.history.append(to_core_message(m))
+    if compat_task.artifacts:
+        for a in compat_task.artifacts:
+            core_task.artifacts.append(to_core_artifact(a))
+    if compat_task.metadata:
+        ParseDict(compat_task.metadata, core_task.metadata)
+    return core_task
+
+
+def to_compat_task(core_task: pb2_v10.Task) -> types_v03.Task:
+    """Convert task to v0.3 compat type."""
+    return types_v03.Task(
+        id=core_task.id,
+        context_id=core_task.context_id,
+        status=to_compat_task_status(core_task.status)
+        if core_task.HasField('status')
+        else types_v03.TaskStatus(state=types_v03.TaskState.unknown),
+        history=[to_compat_message(m) for m in core_task.history]
+        if core_task.history
+        else None,
+        artifacts=[to_compat_artifact(a) for a in core_task.artifacts]
+        if core_task.artifacts
+        else None,
+        metadata=MessageToDict(core_task.metadata)
+        if core_task.HasField('metadata')
+        else None,
+    )
+
+
+def to_core_authentication_info(
+    compat_auth: types_v03.PushNotificationAuthenticationInfo,
+) -> pb2_v10.AuthenticationInfo:
+    """Convert authentication info to v1.0 core type."""
+    core_auth = pb2_v10.AuthenticationInfo()
+    if compat_auth.schemes:
+        core_auth.scheme = compat_auth.schemes[0]
+    if compat_auth.credentials:
+        core_auth.credentials = compat_auth.credentials
+    return core_auth
+
+
+def to_compat_authentication_info(
+    core_auth: pb2_v10.AuthenticationInfo,
+) -> types_v03.PushNotificationAuthenticationInfo:
+    """Convert authentication info to v0.3 compat type."""
+    return types_v03.PushNotificationAuthenticationInfo(
+        schemes=[core_auth.scheme] if core_auth.scheme else [],
+        credentials=core_auth.credentials if core_auth.credentials else None,
+    )
+
+
+def to_core_push_notification_config(
+    compat_config: types_v03.PushNotificationConfig,
+) -> pb2_v10.TaskPushNotificationConfig:
+    """Convert push notification config to v1.0 core type."""
+    core_config = pb2_v10.TaskPushNotificationConfig(url=compat_config.url)
+    if compat_config.id:
+        core_config.id = compat_config.id
+    if compat_config.token:
+        core_config.token = compat_config.token
+    if compat_config.authentication:
+        core_config.authentication.CopyFrom(
+            to_core_authentication_info(compat_config.authentication)
+        )
+    return core_config
+
+
+def to_compat_push_notification_config(
+    core_config: pb2_v10.TaskPushNotificationConfig,
+) -> types_v03.PushNotificationConfig:
+    """Convert push notification config to v0.3 compat type."""
+    return types_v03.PushNotificationConfig(
+        url=core_config.url if core_config.url else '',
+        id=core_config.id if core_config.id else None,
+        token=core_config.token if core_config.token else None,
+        authentication=to_compat_authentication_info(core_config.authentication)
+        if core_config.HasField('authentication')
+        else None,
+    )
+
+
+def to_core_send_message_configuration(
+    compat_config: types_v03.MessageSendConfiguration,
+) -> pb2_v10.SendMessageConfiguration:
+    """Convert send message configuration to v1.0 core type."""
+    core_config = pb2_v10.SendMessageConfiguration()
+    # Result will be blocking by default (return_immediately=False)
+    if compat_config.accepted_output_modes:
+        core_config.accepted_output_modes.extend(
+            compat_config.accepted_output_modes
+        )
+    if compat_config.push_notification_config:
+        core_config.task_push_notification_config.CopyFrom(
+            to_core_push_notification_config(
+                compat_config.push_notification_config
+            )
+        )
+    # v0.3 treats 0 as unlimited, so leave it unset.
+    if compat_config.history_length:
+        core_config.history_length = compat_config.history_length
+    if compat_config.blocking is not None:
+        core_config.return_immediately = not compat_config.blocking
+    return core_config
+
+
+def to_compat_send_message_configuration(
+    core_config: pb2_v10.SendMessageConfiguration,
+) -> types_v03.MessageSendConfiguration:
+    """Convert send message configuration to v0.3 compat type."""
+    return types_v03.MessageSendConfiguration(
+        accepted_output_modes=list(core_config.accepted_output_modes)
+        if core_config.accepted_output_modes
+        else None,
+        push_notification_config=to_compat_push_notification_config(
+            core_config.task_push_notification_config
+        )
+        if core_config.HasField('task_push_notification_config')
+        else None,
+        history_length=core_config.history_length
+        if core_config.HasField('history_length')
+        else None,
+        blocking=not core_config.return_immediately,
+    )
+
+
+def to_core_artifact(compat_artifact: types_v03.Artifact) -> pb2_v10.Artifact:
+    """Convert artifact to v1.0 core type."""
+    core_artifact = pb2_v10.Artifact(artifact_id=compat_artifact.artifact_id)
+    if compat_artifact.name:
+        core_artifact.name = compat_artifact.name
+    if compat_artifact.description:
+        core_artifact.description = compat_artifact.description
+    for p in compat_artifact.parts:
+        core_artifact.parts.append(to_core_part(p))
+    if compat_artifact.metadata:
+        ParseDict(compat_artifact.metadata, core_artifact.metadata)
+    if compat_artifact.extensions:
+        core_artifact.extensions.extend(compat_artifact.extensions)
+    return core_artifact
+
+
+def to_compat_artifact(core_artifact: pb2_v10.Artifact) -> types_v03.Artifact:
+    """Convert artifact to v0.3 compat type."""
+    return types_v03.Artifact(
+        artifact_id=core_artifact.artifact_id,
+        name=core_artifact.name if core_artifact.name else None,
+        description=core_artifact.description
+        if core_artifact.description
+        else None,
+        parts=[to_compat_part(p) for p in core_artifact.parts],
+        metadata=MessageToDict(core_artifact.metadata)
+        if core_artifact.HasField('metadata')
+        else None,
+        extensions=list(core_artifact.extensions)
+        if core_artifact.extensions
+        else None,
+    )
+
+
+def to_core_task_status_update_event(
+    compat_event: types_v03.TaskStatusUpdateEvent,
+) -> pb2_v10.TaskStatusUpdateEvent:
+    """Convert task status update event to v1.0 core type."""
+    core_event = pb2_v10.TaskStatusUpdateEvent(
+        task_id=compat_event.task_id, context_id=compat_event.context_id
+    )
+    if compat_event.status:
+        core_event.status.CopyFrom(to_core_task_status(compat_event.status))
+    if compat_event.metadata:
+        ParseDict(compat_event.metadata, core_event.metadata)
+    return core_event
+
+
+def to_compat_task_status_update_event(
+    core_event: pb2_v10.TaskStatusUpdateEvent,
+) -> types_v03.TaskStatusUpdateEvent:
+    """Convert task status update event to v0.3 compat type."""
+    status = (
+        to_compat_task_status(core_event.status)
+        if core_event.HasField('status')
+        else types_v03.TaskStatus(state=types_v03.TaskState.unknown)
+    )
+    final = status.state in (
+        types_v03.TaskState.completed,
+        types_v03.TaskState.canceled,
+        types_v03.TaskState.failed,
+        types_v03.TaskState.rejected,
+    )
+    return types_v03.TaskStatusUpdateEvent(
+        task_id=core_event.task_id,
+        context_id=core_event.context_id,
+        status=status,
+        metadata=MessageToDict(core_event.metadata)
+        if core_event.HasField('metadata')
+        else None,
+        final=final,
+    )
+
+
+def to_core_task_artifact_update_event(
+    compat_event: types_v03.TaskArtifactUpdateEvent,
+) -> pb2_v10.TaskArtifactUpdateEvent:
+    """Convert task artifact update event to v1.0 core type."""
+    core_event = pb2_v10.TaskArtifactUpdateEvent(
+        task_id=compat_event.task_id, context_id=compat_event.context_id
+    )
+    if compat_event.artifact:
+        core_event.artifact.CopyFrom(to_core_artifact(compat_event.artifact))
+    if compat_event.append is not None:
+        core_event.append = compat_event.append
+    if compat_event.last_chunk is not None:
+        core_event.last_chunk = compat_event.last_chunk
+    if compat_event.metadata:
+        ParseDict(compat_event.metadata, core_event.metadata)
+    return core_event
+
+
+def to_core_security_requirement(
+    compat_req: dict[str, list[str]],
+) -> pb2_v10.SecurityRequirement:
+    """Convert security requirement to v1.0 core type."""
+    core_req = pb2_v10.SecurityRequirement()
+    for scheme_name, scopes in compat_req.items():
+        sl = pb2_v10.StringList()
+        sl.list.extend(scopes)
+        core_req.schemes[scheme_name].CopyFrom(sl)
+    return core_req
+
+
+def to_compat_security_requirement(
+    core_req: pb2_v10.SecurityRequirement,
+) -> dict[str, list[str]]:
+    """Convert security requirement to v0.3 compat type."""
+    return {
+        scheme_name: list(string_list.list)
+        for scheme_name, string_list in core_req.schemes.items()
+    }
+
+
+def to_core_oauth_flows(
+    compat_flows: types_v03.OAuthFlows,
+) -> pb2_v10.OAuthFlows:
+    """Convert oauth flows to v1.0 core type."""
+    core_flows = pb2_v10.OAuthFlows()
+    if compat_flows.authorization_code:
+        f = pb2_v10.AuthorizationCodeOAuthFlow(
+            authorization_url=compat_flows.authorization_code.authorization_url,
+            token_url=compat_flows.authorization_code.token_url,
+            scopes=compat_flows.authorization_code.scopes,
+        )
+        if compat_flows.authorization_code.refresh_url:
+            f.refresh_url = compat_flows.authorization_code.refresh_url
+        core_flows.authorization_code.CopyFrom(f)
+
+    if compat_flows.client_credentials:
+        f_client = pb2_v10.ClientCredentialsOAuthFlow(
+            token_url=compat_flows.client_credentials.token_url,
+            scopes=compat_flows.client_credentials.scopes,
+        )
+        if compat_flows.client_credentials.refresh_url:
+            f_client.refresh_url = compat_flows.client_credentials.refresh_url
+        core_flows.client_credentials.CopyFrom(f_client)
+
+    if compat_flows.implicit:
+        f_impl = pb2_v10.ImplicitOAuthFlow(
+            authorization_url=compat_flows.implicit.authorization_url,
+            scopes=compat_flows.implicit.scopes,
+        )
+        if compat_flows.implicit.refresh_url:
+            f_impl.refresh_url = compat_flows.implicit.refresh_url
+        core_flows.implicit.CopyFrom(f_impl)
+
+    if compat_flows.password:
+        f_pass = pb2_v10.PasswordOAuthFlow(
+            token_url=compat_flows.password.token_url,
+            scopes=compat_flows.password.scopes,
+        )
+        if compat_flows.password.refresh_url:
+            f_pass.refresh_url = compat_flows.password.refresh_url
+        core_flows.password.CopyFrom(f_pass)
+
+    return core_flows
+
+
+def to_compat_oauth_flows(
+    core_flows: pb2_v10.OAuthFlows,
+) -> types_v03.OAuthFlows:
+    """Convert oauth flows to v0.3 compat type."""
+    which = core_flows.WhichOneof('flow')
+    auth_code, client_cred, implicit, password = None, None, None, None
+
+    if which == 'authorization_code':
+        auth_code = types_v03.AuthorizationCodeOAuthFlow(
+            authorization_url=core_flows.authorization_code.authorization_url,
+            token_url=core_flows.authorization_code.token_url,
+            scopes=dict(core_flows.authorization_code.scopes),
+            refresh_url=core_flows.authorization_code.refresh_url
+            if core_flows.authorization_code.refresh_url
+            else None,
+        )
+    elif which == 'client_credentials':
+        client_cred = types_v03.ClientCredentialsOAuthFlow(
+            token_url=core_flows.client_credentials.token_url,
+            scopes=dict(core_flows.client_credentials.scopes),
+            refresh_url=core_flows.client_credentials.refresh_url
+            if core_flows.client_credentials.refresh_url
+            else None,
+        )
+    elif which == 'implicit':
+        implicit = types_v03.ImplicitOAuthFlow(
+            authorization_url=core_flows.implicit.authorization_url,
+            scopes=dict(core_flows.implicit.scopes),
+            refresh_url=core_flows.implicit.refresh_url
+            if core_flows.implicit.refresh_url
+            else None,
+        )
+    elif which == 'password':
+        password = types_v03.PasswordOAuthFlow(
+            token_url=core_flows.password.token_url,
+            scopes=dict(core_flows.password.scopes),
+            refresh_url=core_flows.password.refresh_url
+            if core_flows.password.refresh_url
+            else None,
+        )
+    # Note: device_code from v1.0 is dropped since v0.3 doesn't support it
+
+    return types_v03.OAuthFlows(
+        authorization_code=auth_code,
+        client_credentials=client_cred,
+        implicit=implicit,
+        password=password,
+    )
+
+
+def to_core_security_scheme(
+    compat_scheme: types_v03.SecurityScheme,
+) -> pb2_v10.SecurityScheme:
+    """Convert security scheme to v1.0 core type."""
+    core_scheme = pb2_v10.SecurityScheme()
+    root = compat_scheme.root
+
+    if isinstance(root, types_v03.APIKeySecurityScheme):
+        core_scheme.api_key_security_scheme.location = root.in_.value
+        core_scheme.api_key_security_scheme.name = root.name
+        if root.description:
+            core_scheme.api_key_security_scheme.description = root.description
+
+    elif isinstance(root, types_v03.HTTPAuthSecurityScheme):
+        core_scheme.http_auth_security_scheme.scheme = root.scheme
+        if root.bearer_format:
+            core_scheme.http_auth_security_scheme.bearer_format = (
+                root.bearer_format
+            )
+        if root.description:
+            core_scheme.http_auth_security_scheme.description = root.description
+
+    elif isinstance(root, types_v03.OAuth2SecurityScheme):
+        core_scheme.oauth2_security_scheme.flows.CopyFrom(
+            to_core_oauth_flows(root.flows)
+        )
+        if root.oauth2_metadata_url:
+            core_scheme.oauth2_security_scheme.oauth2_metadata_url = (
+                root.oauth2_metadata_url
+            )
+        if root.description:
+            core_scheme.oauth2_security_scheme.description = root.description
+
+    elif isinstance(root, types_v03.OpenIdConnectSecurityScheme):
+        core_scheme.open_id_connect_security_scheme.open_id_connect_url = (
+            root.open_id_connect_url
+        )
+        if root.description:
+            core_scheme.open_id_connect_security_scheme.description = (
+                root.description
+            )
+
+    elif isinstance(root, types_v03.MutualTLSSecurityScheme):
+        # Mutual TLS has no required fields other than description which is optional
+        core_scheme.mtls_security_scheme.SetInParent()
+        if root.description:
+            core_scheme.mtls_security_scheme.description = root.description
+
+    return core_scheme
+
+
+def to_compat_security_scheme(
+    core_scheme: pb2_v10.SecurityScheme,
+) -> types_v03.SecurityScheme:
+    """Convert security scheme to v0.3 compat type."""
+    which = core_scheme.WhichOneof('scheme')
+
+    if which == 'api_key_security_scheme':
+        s_api = core_scheme.api_key_security_scheme
+        return types_v03.SecurityScheme(
+            root=types_v03.APIKeySecurityScheme(
+                in_=types_v03.In(s_api.location),
+                name=s_api.name,
+                description=s_api.description if s_api.description else None,
+            )
+        )
+
+    if which == 'http_auth_security_scheme':
+        s_http = core_scheme.http_auth_security_scheme
+        return types_v03.SecurityScheme(
+            root=types_v03.HTTPAuthSecurityScheme(
+                scheme=s_http.scheme,
+                bearer_format=s_http.bearer_format
+                if s_http.bearer_format
+                else None,
+                description=s_http.description if s_http.description else None,
+            )
+        )
+
+    if which == 'oauth2_security_scheme':
+        s_oauth = core_scheme.oauth2_security_scheme
+        return types_v03.SecurityScheme(
+            root=types_v03.OAuth2SecurityScheme(
+                flows=to_compat_oauth_flows(s_oauth.flows),
+                oauth2_metadata_url=s_oauth.oauth2_metadata_url
+                if s_oauth.oauth2_metadata_url
+                else None,
+                description=s_oauth.description
+                if s_oauth.description
+                else None,
+            )
+        )
+
+    if which == 'open_id_connect_security_scheme':
+        s_oidc = core_scheme.open_id_connect_security_scheme
+        return types_v03.SecurityScheme(
+            root=types_v03.OpenIdConnectSecurityScheme(
+                open_id_connect_url=s_oidc.open_id_connect_url,
+                description=s_oidc.description if s_oidc.description else None,
+            )
+        )
+
+    if which == 'mtls_security_scheme':
+        s_mtls = core_scheme.mtls_security_scheme
+        return types_v03.SecurityScheme(
+            root=types_v03.MutualTLSSecurityScheme(
+                description=s_mtls.description if s_mtls.description else None
+            )
+        )
+
+    raise ValueError(f'Unknown security scheme type: {which}')
+
+
+def to_core_agent_interface(
+    compat_interface: types_v03.AgentInterface,
+) -> pb2_v10.AgentInterface:
+    """Convert agent interface to v1.0 core type."""
+    return pb2_v10.AgentInterface(
+        url=compat_interface.url,
+        protocol_binding=compat_interface.transport,
+        protocol_version=constants.PROTOCOL_VERSION_0_3,  # Defaulting for legacy
+    )
+
+
+def to_compat_agent_interface(
+    core_interface: pb2_v10.AgentInterface,
+) -> types_v03.AgentInterface:
+    """Convert agent interface to v0.3 compat type."""
+    return types_v03.AgentInterface(
+        url=core_interface.url, transport=core_interface.protocol_binding
+    )
+
+
+def to_core_agent_provider(
+    compat_provider: types_v03.AgentProvider,
+) -> pb2_v10.AgentProvider:
+    """Convert agent provider to v1.0 core type."""
+    return pb2_v10.AgentProvider(
+        url=compat_provider.url, organization=compat_provider.organization
+    )
+
+
+def to_compat_agent_provider(
+    core_provider: pb2_v10.AgentProvider,
+) -> types_v03.AgentProvider:
+    """Convert agent provider to v0.3 compat type."""
+    return types_v03.AgentProvider(
+        url=core_provider.url, organization=core_provider.organization
+    )
+
+
+def to_core_agent_extension(
+    compat_ext: types_v03.AgentExtension,
+) -> pb2_v10.AgentExtension:
+    """Convert agent extension to v1.0 core type."""
+    core_ext = pb2_v10.AgentExtension()
+    if compat_ext.uri:
+        core_ext.uri = compat_ext.uri
+    if compat_ext.description:
+        core_ext.description = compat_ext.description
+    if compat_ext.required is not None:
+        core_ext.required = compat_ext.required
+    if compat_ext.params:
+        ParseDict(compat_ext.params, core_ext.params)
+    return core_ext
+
+
+def to_compat_agent_extension(
+    core_ext: pb2_v10.AgentExtension,
+) -> types_v03.AgentExtension:
+    """Convert agent extension to v0.3 compat type."""
+    return types_v03.AgentExtension(
+        uri=core_ext.uri,
+        description=core_ext.description if core_ext.description else None,
+        required=core_ext.required,
+        params=MessageToDict(core_ext.params)
+        if core_ext.HasField('params')
+        else None,
+    )
+
+
+def to_core_agent_capabilities(
+    compat_cap: types_v03.AgentCapabilities,
+) -> pb2_v10.AgentCapabilities:
+    """Convert agent capabilities to v1.0 core type."""
+    core_cap = pb2_v10.AgentCapabilities()
+    if compat_cap.streaming is not None:
+        core_cap.streaming = compat_cap.streaming
+    if compat_cap.push_notifications is not None:
+        core_cap.push_notifications = compat_cap.push_notifications
+    if compat_cap.extensions:
+        core_cap.extensions.extend(
+            [to_core_agent_extension(e) for e in compat_cap.extensions]
+        )
+    return core_cap
+
+
+def to_compat_agent_capabilities(
+    core_cap: pb2_v10.AgentCapabilities,
+) -> types_v03.AgentCapabilities:
+    """Convert agent capabilities to v0.3 compat type."""
+    return types_v03.AgentCapabilities(
+        streaming=core_cap.streaming
+        if core_cap.HasField('streaming')
+        else None,
+        push_notifications=core_cap.push_notifications
+        if core_cap.HasField('push_notifications')
+        else None,
+        extensions=[to_compat_agent_extension(e) for e in core_cap.extensions]
+        if core_cap.extensions
+        else None,
+        state_transition_history=None,  # No longer supported in v1.0
+    )
+
+
+def to_core_agent_skill(
+    compat_skill: types_v03.AgentSkill,
+) -> pb2_v10.AgentSkill:
+    """Convert agent skill to v1.0 core type."""
+    core_skill = pb2_v10.AgentSkill(
+        id=compat_skill.id,
+        name=compat_skill.name,
+        description=compat_skill.description,
+    )
+    if compat_skill.tags:
+        core_skill.tags.extend(compat_skill.tags)
+    if compat_skill.examples:
+        core_skill.examples.extend(compat_skill.examples)
+    if compat_skill.input_modes:
+        core_skill.input_modes.extend(compat_skill.input_modes)
+    if compat_skill.output_modes:
+        core_skill.output_modes.extend(compat_skill.output_modes)
+    if compat_skill.security:
+        core_skill.security_requirements.extend(
+            [to_core_security_requirement(r) for r in compat_skill.security]
+        )
+    return core_skill
+
+
+def to_compat_agent_skill(
+    core_skill: pb2_v10.AgentSkill,
+) -> types_v03.AgentSkill:
+    """Convert agent skill to v0.3 compat type."""
+    return types_v03.AgentSkill(
+        id=core_skill.id,
+        name=core_skill.name,
+        description=core_skill.description,
+        tags=list(core_skill.tags) if core_skill.tags else [],
+        examples=list(core_skill.examples) if core_skill.examples else None,
+        input_modes=list(core_skill.input_modes)
+        if core_skill.input_modes
+        else None,
+        output_modes=list(core_skill.output_modes)
+        if core_skill.output_modes
+        else None,
+        security=[
+            to_compat_security_requirement(r)
+            for r in core_skill.security_requirements
+        ]
+        if core_skill.security_requirements
+        else None,
+    )
+
+
+def to_core_agent_card_signature(
+    compat_sig: types_v03.AgentCardSignature,
+) -> pb2_v10.AgentCardSignature:
+    """Convert agent card signature to v1.0 core type."""
+    core_sig = pb2_v10.AgentCardSignature(
+        protected=compat_sig.protected, signature=compat_sig.signature
+    )
+    if compat_sig.header:
+        ParseDict(compat_sig.header, core_sig.header)
+    return core_sig
+
+
+def to_compat_agent_card_signature(
+    core_sig: pb2_v10.AgentCardSignature,
+) -> types_v03.AgentCardSignature:
+    """Convert agent card signature to v0.3 compat type."""
+    return types_v03.AgentCardSignature(
+        protected=core_sig.protected,
+        signature=core_sig.signature,
+        header=MessageToDict(core_sig.header)
+        if core_sig.HasField('header')
+        else None,
+    )
+
+
+def to_core_agent_card(compat_card: types_v03.AgentCard) -> pb2_v10.AgentCard:
+    """Convert agent card to v1.0 core type."""
+    core_card = pb2_v10.AgentCard(
+        name=compat_card.name,
+        description=compat_card.description,
+        version=compat_card.version,
+    )
+
+    # Map primary interface
+    primary_interface = pb2_v10.AgentInterface(
+        url=compat_card.url,
+        protocol_binding=compat_card.preferred_transport or 'JSONRPC',
+        protocol_version=compat_card.protocol_version
+        or constants.PROTOCOL_VERSION_0_3,
+    )
+    core_card.supported_interfaces.append(primary_interface)
+
+    if compat_card.additional_interfaces:
+        core_card.supported_interfaces.extend(
+            [
+                to_core_agent_interface(i)
+                for i in compat_card.additional_interfaces
+            ]
+        )
+
+    if compat_card.provider:
+        core_card.provider.CopyFrom(
+            to_core_agent_provider(compat_card.provider)
+        )
+
+    if compat_card.documentation_url:
+        core_card.documentation_url = compat_card.documentation_url
+
+    if compat_card.icon_url:
+        core_card.icon_url = compat_card.icon_url
+
+    core_cap = to_core_agent_capabilities(compat_card.capabilities)
+    if compat_card.supports_authenticated_extended_card is not None:
+        core_cap.extended_agent_card = (
+            compat_card.supports_authenticated_extended_card
+        )
+    core_card.capabilities.CopyFrom(core_cap)
+
+    if compat_card.security_schemes:
+        for k, v in compat_card.security_schemes.items():
+            core_card.security_schemes[k].CopyFrom(to_core_security_scheme(v))
+
+    if compat_card.security:
+        core_card.security_requirements.extend(
+            [to_core_security_requirement(r) for r in compat_card.security]
+        )
+
+    if compat_card.default_input_modes:
+        core_card.default_input_modes.extend(compat_card.default_input_modes)
+
+    if compat_card.default_output_modes:
+        core_card.default_output_modes.extend(compat_card.default_output_modes)
+
+    if compat_card.skills:
+        core_card.skills.extend(
+            [to_core_agent_skill(s) for s in compat_card.skills]
+        )
+
+    if compat_card.signatures:
+        core_card.signatures.extend(
+            [to_core_agent_card_signature(s) for s in compat_card.signatures]
+        )
+
+    return core_card
+
+
+def to_compat_agent_card(core_card: pb2_v10.AgentCard) -> types_v03.AgentCard:
+    # Map supported interfaces back to legacy layout
+    """Convert agent card to v0.3 compat type."""
+    compat_interfaces = [
+        interface
+        for interface in core_card.supported_interfaces
+        if (
+            (not interface.protocol_version)
+            or is_legacy_version(interface.protocol_version)
+        )
+    ]
+    if not compat_interfaces:
+        raise errors.VersionNotSupportedError(
+            'AgentCard must have at least one interface with compatible protocol version.'
+        )
+
+    primary_interface = compat_interfaces[0]
+    additional_interfaces = [
+        to_compat_agent_interface(i) for i in compat_interfaces[1:]
+    ]
+
+    compat_cap = to_compat_agent_capabilities(core_card.capabilities)
+    supports_authenticated_extended_card = (
+        core_card.capabilities.extended_agent_card
+        if core_card.capabilities.HasField('extended_agent_card')
+        else None
+    )
+
+    return types_v03.AgentCard(
+        name=core_card.name,
+        description=core_card.description,
+        version=core_card.version,
+        url=primary_interface.url,
+        preferred_transport=primary_interface.protocol_binding,
+        protocol_version=primary_interface.protocol_version
+        or constants.PROTOCOL_VERSION_0_3,
+        additional_interfaces=additional_interfaces or None,
+        provider=to_compat_agent_provider(core_card.provider)
+        if core_card.HasField('provider')
+        else None,
+        documentation_url=core_card.documentation_url
+        if core_card.HasField('documentation_url')
+        else None,
+        icon_url=core_card.icon_url if core_card.HasField('icon_url') else None,
+        capabilities=compat_cap,
+        supports_authenticated_extended_card=supports_authenticated_extended_card,
+        security_schemes={
+            k: to_compat_security_scheme(v)
+            for k, v in core_card.security_schemes.items()
+        }
+        if core_card.security_schemes
+        else None,
+        security=[
+            to_compat_security_requirement(r)
+            for r in core_card.security_requirements
+        ]
+        if core_card.security_requirements
+        else None,
+        default_input_modes=list(core_card.default_input_modes)
+        if core_card.default_input_modes
+        else [],
+        default_output_modes=list(core_card.default_output_modes)
+        if core_card.default_output_modes
+        else [],
+        skills=[to_compat_agent_skill(s) for s in core_card.skills]
+        if core_card.skills
+        else [],
+        signatures=[
+            to_compat_agent_card_signature(s) for s in core_card.signatures
+        ]
+        if core_card.signatures
+        else None,
+    )
+
+
+def to_compat_task_artifact_update_event(
+    core_event: pb2_v10.TaskArtifactUpdateEvent,
+) -> types_v03.TaskArtifactUpdateEvent:
+    """Convert task artifact update event to v0.3 compat type."""
+    return types_v03.TaskArtifactUpdateEvent(
+        task_id=core_event.task_id,
+        context_id=core_event.context_id,
+        artifact=to_compat_artifact(core_event.artifact),
+        append=core_event.append,
+        last_chunk=core_event.last_chunk,
+        metadata=MessageToDict(core_event.metadata)
+        if core_event.HasField('metadata')
+        else None,
+    )
+
+
+def to_core_task_push_notification_config(
+    compat_config: types_v03.TaskPushNotificationConfig,
+) -> pb2_v10.TaskPushNotificationConfig:
+    """Convert task push notification config to v1.0 core type."""
+    core_config = pb2_v10.TaskPushNotificationConfig(
+        task_id=compat_config.task_id
+    )
+    if compat_config.push_notification_config:
+        core_config.MergeFrom(
+            to_core_push_notification_config(
+                compat_config.push_notification_config
+            )
+        )
+    return core_config
+
+
+def to_compat_task_push_notification_config(
+    core_config: pb2_v10.TaskPushNotificationConfig,
+) -> types_v03.TaskPushNotificationConfig:
+    """Convert task push notification config to v0.3 compat type."""
+    return types_v03.TaskPushNotificationConfig(
+        task_id=core_config.task_id,
+        push_notification_config=to_compat_push_notification_config(
+            core_config
+        ),
+    )
+
+
+def to_core_send_message_request(
+    compat_req: types_v03.SendMessageRequest,
+) -> pb2_v10.SendMessageRequest:
+    """Convert send message request to v1.0 core type."""
+    core_req = pb2_v10.SendMessageRequest()
+    if compat_req.params.message:
+        core_req.message.CopyFrom(to_core_message(compat_req.params.message))
+    if compat_req.params.configuration:
+        core_req.configuration.CopyFrom(
+            to_core_send_message_configuration(compat_req.params.configuration)
+        )
+    if compat_req.params.metadata:
+        ParseDict(compat_req.params.metadata, core_req.metadata)
+    return core_req
+
+
+def to_compat_send_message_request(
+    core_req: pb2_v10.SendMessageRequest, request_id: str | int
+) -> types_v03.SendMessageRequest:
+    """Convert send message request to v0.3 compat type."""
+    return types_v03.SendMessageRequest(
+        id=request_id,
+        params=types_v03.MessageSendParams(
+            message=to_compat_message(core_req.message),
+            configuration=to_compat_send_message_configuration(
+                core_req.configuration
+            )
+            if core_req.HasField('configuration')
+            else None,
+            metadata=MessageToDict(core_req.metadata)
+            if core_req.HasField('metadata')
+            else None,
+        ),
+    )
+
+
+def to_core_get_task_request(
+    compat_req: types_v03.GetTaskRequest,
+) -> pb2_v10.GetTaskRequest:
+    """Convert get task request to v1.0 core type."""
+    core_req = pb2_v10.GetTaskRequest()
+    core_req.id = compat_req.params.id
+    # v0.3 treats 0 as unlimited, so leave it unset.
+    if compat_req.params.history_length:
+        core_req.history_length = compat_req.params.history_length
+    return core_req
+
+
+def to_compat_get_task_request(
+    core_req: pb2_v10.GetTaskRequest, request_id: str | int
+) -> types_v03.GetTaskRequest:
+    """Convert get task request to v0.3 compat type."""
+    return types_v03.GetTaskRequest(
+        id=request_id,
+        params=types_v03.TaskQueryParams(
+            id=core_req.id,
+            history_length=core_req.history_length
+            if core_req.HasField('history_length')
+            else None,
+        ),
+    )
+
+
+def to_core_cancel_task_request(
+    compat_req: types_v03.CancelTaskRequest,
+) -> pb2_v10.CancelTaskRequest:
+    """Convert cancel task request to v1.0 core type."""
+    core_req = pb2_v10.CancelTaskRequest(id=compat_req.params.id)
+    if compat_req.params.metadata:
+        ParseDict(compat_req.params.metadata, core_req.metadata)
+    return core_req
+
+
+def to_compat_cancel_task_request(
+    core_req: pb2_v10.CancelTaskRequest, request_id: str | int
+) -> types_v03.CancelTaskRequest:
+    """Convert cancel task request to v0.3 compat type."""
+    return types_v03.CancelTaskRequest(
+        id=request_id,
+        params=types_v03.TaskIdParams(
+            id=core_req.id,
+            metadata=MessageToDict(core_req.metadata)
+            if core_req.HasField('metadata')
+            else None,
+        ),
+    )
+
+
+def to_core_get_task_push_notification_config_request(
+    compat_req: types_v03.GetTaskPushNotificationConfigRequest,
+) -> pb2_v10.GetTaskPushNotificationConfigRequest:
+    """Convert get task push notification config request to v1.0 core type."""
+    if isinstance(
+        compat_req.params, types_v03.GetTaskPushNotificationConfigParams
+    ):
+        return pb2_v10.GetTaskPushNotificationConfigRequest(
+            task_id=compat_req.params.id,
+            id=compat_req.params.push_notification_config_id,
+        )
+    return pb2_v10.GetTaskPushNotificationConfigRequest(
+        task_id=compat_req.params.id
+    )
+
+
+def to_compat_get_task_push_notification_config_request(
+    core_req: pb2_v10.GetTaskPushNotificationConfigRequest,
+    request_id: str | int,
+) -> types_v03.GetTaskPushNotificationConfigRequest:
+    """Convert get task push notification config request to v0.3 compat type."""
+    params: (
+        types_v03.GetTaskPushNotificationConfigParams | types_v03.TaskIdParams
+    )
+    if core_req.id:
+        params = types_v03.GetTaskPushNotificationConfigParams(
+            id=core_req.task_id, push_notification_config_id=core_req.id
+        )
+    else:
+        params = types_v03.TaskIdParams(id=core_req.task_id)
+    return types_v03.GetTaskPushNotificationConfigRequest(
+        id=request_id, params=params
+    )
+
+
+def to_core_delete_task_push_notification_config_request(
+    compat_req: types_v03.DeleteTaskPushNotificationConfigRequest,
+) -> pb2_v10.DeleteTaskPushNotificationConfigRequest:
+    """Convert delete task push notification config request to v1.0 core type."""
+    return pb2_v10.DeleteTaskPushNotificationConfigRequest(
+        task_id=compat_req.params.id,
+        id=compat_req.params.push_notification_config_id,
+    )
+
+
+def to_compat_delete_task_push_notification_config_request(
+    core_req: pb2_v10.DeleteTaskPushNotificationConfigRequest,
+    request_id: str | int,
+) -> types_v03.DeleteTaskPushNotificationConfigRequest:
+    """Convert delete task push notification config request to v0.3 compat type."""
+    return types_v03.DeleteTaskPushNotificationConfigRequest(
+        id=request_id,
+        params=types_v03.DeleteTaskPushNotificationConfigParams(
+            id=core_req.task_id, push_notification_config_id=core_req.id
+        ),
+    )
+
+
+def to_core_create_task_push_notification_config_request(
+    compat_req: types_v03.SetTaskPushNotificationConfigRequest,
+) -> pb2_v10.TaskPushNotificationConfig:
+    """Convert create task push notification config request to v1.0 core type."""
+    core_req = pb2_v10.TaskPushNotificationConfig(
+        task_id=compat_req.params.task_id
+    )
+    if compat_req.params.push_notification_config:
+        core_req.MergeFrom(
+            to_core_push_notification_config(
+                compat_req.params.push_notification_config
+            )
+        )
+    return core_req
+
+
+def to_compat_create_task_push_notification_config_request(
+    core_req: pb2_v10.TaskPushNotificationConfig,
+    request_id: str | int,
+) -> types_v03.SetTaskPushNotificationConfigRequest:
+    """Convert create task push notification config request to v0.3 compat type."""
+    return types_v03.SetTaskPushNotificationConfigRequest(
+        id=request_id,
+        params=types_v03.TaskPushNotificationConfig(
+            task_id=core_req.task_id,
+            push_notification_config=to_compat_push_notification_config(
+                core_req
+            ),
+        ),
+    )
+
+
+def to_core_subscribe_to_task_request(
+    compat_req: types_v03.TaskResubscriptionRequest,
+) -> pb2_v10.SubscribeToTaskRequest:
+    """Convert subscribe to task request to v1.0 core type."""
+    return pb2_v10.SubscribeToTaskRequest(id=compat_req.params.id)
+
+
+def to_compat_subscribe_to_task_request(
+    core_req: pb2_v10.SubscribeToTaskRequest, request_id: str | int
+) -> types_v03.TaskResubscriptionRequest:
+    """Convert subscribe to task request to v0.3 compat type."""
+    return types_v03.TaskResubscriptionRequest(
+        id=request_id, params=types_v03.TaskIdParams(id=core_req.id)
+    )
+
+
+def to_core_list_task_push_notification_config_request(
+    compat_req: types_v03.ListTaskPushNotificationConfigRequest,
+) -> pb2_v10.ListTaskPushNotificationConfigsRequest:
+    """Convert list task push notification config request to v1.0 core type."""
+    core_req = pb2_v10.ListTaskPushNotificationConfigsRequest()
+    if compat_req.params.id:
+        core_req.task_id = compat_req.params.id
+    return core_req
+
+
+def to_compat_list_task_push_notification_config_request(
+    core_req: pb2_v10.ListTaskPushNotificationConfigsRequest,
+    request_id: str | int,
+) -> types_v03.ListTaskPushNotificationConfigRequest:
+    """Convert list task push notification config request to v0.3 compat type."""
+    return types_v03.ListTaskPushNotificationConfigRequest(
+        id=request_id,
+        params=types_v03.ListTaskPushNotificationConfigParams(
+            id=core_req.task_id
+        ),
+    )
+
+
+def to_core_list_task_push_notification_config_response(
+    compat_res: types_v03.ListTaskPushNotificationConfigResponse,
+) -> pb2_v10.ListTaskPushNotificationConfigsResponse:
+    """Convert list task push notification config response to v1.0 core type."""
+    core_res = pb2_v10.ListTaskPushNotificationConfigsResponse()
+    root = compat_res.root
+    if isinstance(
+        root, types_v03.ListTaskPushNotificationConfigSuccessResponse
+    ):
+        for c in root.result:
+            core_res.configs.append(to_core_task_push_notification_config(c))
+    return core_res
+
+
+def to_compat_list_task_push_notification_config_response(
+    core_res: pb2_v10.ListTaskPushNotificationConfigsResponse,
+    request_id: str | int | None = None,
+) -> types_v03.ListTaskPushNotificationConfigResponse:
+    """Convert list task push notification config response to v0.3 compat type."""
+    return types_v03.ListTaskPushNotificationConfigResponse(
+        root=types_v03.ListTaskPushNotificationConfigSuccessResponse(
+            id=request_id,
+            result=[
+                to_compat_task_push_notification_config(c)
+                for c in core_res.configs
+            ],
+        )
+    )
+
+
+def to_core_send_message_response(
+    compat_res: types_v03.SendMessageResponse,
+) -> pb2_v10.SendMessageResponse:
+    """Convert send message response to v1.0 core type."""
+    core_res = pb2_v10.SendMessageResponse()
+    root = compat_res.root
+    if isinstance(root, types_v03.SendMessageSuccessResponse):
+        if isinstance(root.result, types_v03.Task):
+            core_res.task.CopyFrom(to_core_task(root.result))
+        else:
+            core_res.message.CopyFrom(to_core_message(root.result))
+    return core_res
+
+
+def to_compat_send_message_response(
+    core_res: pb2_v10.SendMessageResponse, request_id: str | int | None = None
+) -> types_v03.SendMessageResponse:
+    """Convert send message response to v0.3 compat type."""
+    if core_res.HasField('task'):
+        result_task = to_compat_task(core_res.task)
+        return types_v03.SendMessageResponse(
+            root=types_v03.SendMessageSuccessResponse(
+                id=request_id, result=result_task
+            )
+        )
+    result_msg = to_compat_message(core_res.message)
+    return types_v03.SendMessageResponse(
+        root=types_v03.SendMessageSuccessResponse(
+            id=request_id, result=result_msg
+        )
+    )
+
+
+def to_core_stream_response(
+    compat_res: types_v03.SendStreamingMessageSuccessResponse,
+) -> pb2_v10.StreamResponse:
+    """Convert stream response to v1.0 core type."""
+    core_res = pb2_v10.StreamResponse()
+    root = compat_res.result
+
+    if isinstance(root, types_v03.Message):
+        core_res.message.CopyFrom(to_core_message(root))
+    elif isinstance(root, types_v03.Task):
+        core_res.task.CopyFrom(to_core_task(root))
+    elif isinstance(root, types_v03.TaskStatusUpdateEvent):
+        core_res.status_update.CopyFrom(to_core_task_status_update_event(root))
+    elif isinstance(root, types_v03.TaskArtifactUpdateEvent):
+        core_res.artifact_update.CopyFrom(
+            to_core_task_artifact_update_event(root)
+        )
+
+    return core_res
+
+
+def to_compat_stream_response(
+    core_res: pb2_v10.StreamResponse, request_id: str | int | None = None
+) -> types_v03.SendStreamingMessageSuccessResponse:
+    """Convert stream response to v0.3 compat type."""
+    which = core_res.WhichOneof('payload')
+    if which == 'message':
+        return types_v03.SendStreamingMessageSuccessResponse(
+            id=request_id, result=to_compat_message(core_res.message)
+        )
+    if which == 'task':
+        return types_v03.SendStreamingMessageSuccessResponse(
+            id=request_id, result=to_compat_task(core_res.task)
+        )
+    if which == 'status_update':
+        return types_v03.SendStreamingMessageSuccessResponse(
+            id=request_id,
+            result=to_compat_task_status_update_event(core_res.status_update),
+        )
+    if which == 'artifact_update':
+        return types_v03.SendStreamingMessageSuccessResponse(
+            id=request_id,
+            result=to_compat_task_artifact_update_event(
+                core_res.artifact_update
+            ),
+        )
+
+    raise ValueError(f'Unknown stream response event type: {which}')
+
+
+def to_core_get_extended_agent_card_request(
+    compat_req: types_v03.GetAuthenticatedExtendedCardRequest,
+) -> pb2_v10.GetExtendedAgentCardRequest:
+    """Convert get extended agent card request to v1.0 core type."""
+    return pb2_v10.GetExtendedAgentCardRequest()
+
+
+def to_compat_get_extended_agent_card_request(
+    core_req: pb2_v10.GetExtendedAgentCardRequest, request_id: str | int
+) -> types_v03.GetAuthenticatedExtendedCardRequest:
+    """Convert get extended agent card request to v0.3 compat type."""
+    return types_v03.GetAuthenticatedExtendedCardRequest(id=request_id)
diff --git a/src/a2a/compat/v0_3/extension_headers.py b/src/a2a/compat/v0_3/extension_headers.py
new file mode 100644
index 000000000..e1421a0b0
--- /dev/null
+++ b/src/a2a/compat/v0_3/extension_headers.py
@@ -0,0 +1,27 @@
+"""Shared header name constants for v0.3 extension compatibility.
+
+The current spec uses ``A2A-Extensions``. v0.3 used the ``X-`` prefixed
+``X-A2A-Extensions`` form. v0.3 compat servers and clients accept/emit both
+names so they can interoperate with peers that only know the legacy one.
+"""
+
+from a2a.client.service_parameters import ServiceParameters
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+
+
+LEGACY_HTTP_EXTENSION_HEADER = f'X-{HTTP_EXTENSION_HEADER}'
+
+
+def add_legacy_extension_header(parameters: ServiceParameters) -> None:
+    """Mirrors the ``A2A-Extensions`` parameter under its legacy name in-place.
+
+    Used by v0.3 compat client transports so that requests can be understood
+    by older v0.3 servers that only recognize ``X-A2A-Extensions``.
+    """
+    if (
+        HTTP_EXTENSION_HEADER in parameters
+        and LEGACY_HTTP_EXTENSION_HEADER not in parameters
+    ):
+        parameters[LEGACY_HTTP_EXTENSION_HEADER] = parameters[
+            HTTP_EXTENSION_HEADER
+        ]
diff --git a/src/a2a/compat/v0_3/grpc_handler.py b/src/a2a/compat/v0_3/grpc_handler.py
new file mode 100644
index 000000000..b7bec26ea
--- /dev/null
+++ b/src/a2a/compat/v0_3/grpc_handler.py
@@ -0,0 +1,362 @@
+# ruff: noqa: N802
+import logging
+
+from collections.abc import AsyncIterable, Awaitable, Callable
+from typing import TypeVar
+
+import grpc
+import grpc.aio
+
+from google.protobuf import empty_pb2
+
+from a2a.compat.v0_3 import (
+    a2a_v0_3_pb2,
+    a2a_v0_3_pb2_grpc,
+    proto_utils,
+)
+from a2a.compat.v0_3 import (
+    types as types_v03,
+)
+from a2a.compat.v0_3.context_builders import V03GrpcServerCallContextBuilder
+from a2a.compat.v0_3.request_handler import RequestHandler03
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.grpc_handler import (
+    _ERROR_CODE_MAP,
+    DefaultGrpcServerCallContextBuilder,
+    GrpcServerCallContextBuilder,
+)
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.utils.errors import A2AError, InvalidParamsError
+
+
+logger = logging.getLogger(__name__)
+
+TResponse = TypeVar('TResponse')
+
+
+class CompatGrpcHandler(a2a_v0_3_pb2_grpc.A2AServiceServicer):
+    """Backward compatible gRPC handler for A2A v0.3."""
+
+    def __init__(
+        self,
+        request_handler: RequestHandler,
+        context_builder: GrpcServerCallContextBuilder | None = None,
+    ):
+        """Initializes the CompatGrpcHandler.
+
+        Args:
+            request_handler: The underlying `RequestHandler` instance to
+                             delegate requests to.
+            context_builder: The CallContextBuilder object. If none the
+                             DefaultCallContextBuilder is used.
+        """
+        self.handler03 = RequestHandler03(request_handler=request_handler)
+        self._context_builder = V03GrpcServerCallContextBuilder(
+            context_builder or DefaultGrpcServerCallContextBuilder()
+        )
+
+    async def _handle_unary(
+        self,
+        context: grpc.aio.ServicerContext,
+        handler_func: Callable[[ServerCallContext], Awaitable[TResponse]],
+        default_response: TResponse,
+    ) -> TResponse:
+        """Centralized error handling and context management for unary calls."""
+        try:
+            server_context = self._context_builder.build(context)
+            result = await handler_func(server_context)
+        except A2AError as e:
+            await self.abort_context(e, context)
+        else:
+            return result
+        return default_response
+
+    async def _handle_stream(
+        self,
+        context: grpc.aio.ServicerContext,
+        handler_func: Callable[[ServerCallContext], AsyncIterable[TResponse]],
+    ) -> AsyncIterable[TResponse]:
+        """Centralized error handling and context management for streaming calls."""
+        try:
+            server_context = self._context_builder.build(context)
+            async for item in handler_func(server_context):
+                yield item
+        except A2AError as e:
+            await self.abort_context(e, context)
+
+    def _extract_task_id(self, resource_name: str) -> str:
+        """Extracts task_id from resource name."""
+        m = proto_utils.TASK_NAME_MATCH.match(resource_name)
+        if not m:
+            raise InvalidParamsError(message=f'No task for {resource_name}')
+        return m.group(1)
+
+    def _extract_task_and_config_id(
+        self, resource_name: str
+    ) -> tuple[str, str]:
+        """Extracts task_id and config_id from resource name."""
+        m = proto_utils.TASK_PUSH_CONFIG_NAME_MATCH.match(resource_name)
+        if not m:
+            raise InvalidParamsError(
+                message=f'Bad resource name {resource_name}'
+            )
+        return m.group(1), m.group(2)
+
+    async def abort_context(
+        self, error: A2AError, context: grpc.aio.ServicerContext
+    ) -> None:
+        """Sets the grpc errors appropriately in the context."""
+        code = _ERROR_CODE_MAP.get(type(error))
+        if code:
+            await context.abort(
+                code,
+                f'{type(error).__name__}: {error.message}',
+            )
+        else:
+            await context.abort(
+                grpc.StatusCode.UNKNOWN,
+                f'Unknown error type: {error}',
+            )
+
+    async def SendMessage(
+        self,
+        request: a2a_v0_3_pb2.SendMessageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.SendMessageResponse:
+        """Handles the 'SendMessage' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.SendMessageResponse:
+            req_v03 = types_v03.SendMessageRequest(
+                id=0, params=proto_utils.FromProto.message_send_params(request)
+            )
+            result = await self.handler03.on_message_send(
+                req_v03, server_context
+            )
+            if isinstance(result, types_v03.Task):
+                return a2a_v0_3_pb2.SendMessageResponse(
+                    task=proto_utils.ToProto.task(result)
+                )
+            return a2a_v0_3_pb2.SendMessageResponse(
+                msg=proto_utils.ToProto.message(result)
+            )
+
+        return await self._handle_unary(
+            context, _handler, a2a_v0_3_pb2.SendMessageResponse()
+        )
+
+    async def SendStreamingMessage(
+        self,
+        request: a2a_v0_3_pb2.SendMessageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> AsyncIterable[a2a_v0_3_pb2.StreamResponse]:
+        """Handles the 'SendStreamingMessage' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> AsyncIterable[a2a_v0_3_pb2.StreamResponse]:
+            req_v03 = types_v03.SendMessageRequest(
+                id=0, params=proto_utils.FromProto.message_send_params(request)
+            )
+            async for v03_stream_resp in self.handler03.on_message_send_stream(
+                req_v03, server_context
+            ):
+                yield proto_utils.ToProto.stream_response(
+                    v03_stream_resp.result
+                )
+
+        async for item in self._handle_stream(context, _handler):
+            yield item
+
+    async def GetTask(
+        self,
+        request: a2a_v0_3_pb2.GetTaskRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.Task:
+        """Handles the 'GetTask' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.Task:
+            req_v03 = types_v03.GetTaskRequest(
+                id=0, params=proto_utils.FromProto.task_query_params(request)
+            )
+            task = await self.handler03.on_get_task(req_v03, server_context)
+            return proto_utils.ToProto.task(task)
+
+        return await self._handle_unary(context, _handler, a2a_v0_3_pb2.Task())
+
+    async def CancelTask(
+        self,
+        request: a2a_v0_3_pb2.CancelTaskRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.Task:
+        """Handles the 'CancelTask' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.Task:
+            req_v03 = types_v03.CancelTaskRequest(
+                id=0, params=proto_utils.FromProto.task_id_params(request)
+            )
+            task = await self.handler03.on_cancel_task(req_v03, server_context)
+            return proto_utils.ToProto.task(task)
+
+        return await self._handle_unary(context, _handler, a2a_v0_3_pb2.Task())
+
+    async def TaskSubscription(
+        self,
+        request: a2a_v0_3_pb2.TaskSubscriptionRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> AsyncIterable[a2a_v0_3_pb2.StreamResponse]:
+        """Handles the 'TaskSubscription' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> AsyncIterable[a2a_v0_3_pb2.StreamResponse]:
+            req_v03 = types_v03.TaskResubscriptionRequest(
+                id=0, params=proto_utils.FromProto.task_id_params(request)
+            )
+            async for v03_stream_resp in self.handler03.on_subscribe_to_task(
+                req_v03, server_context
+            ):
+                yield proto_utils.ToProto.stream_response(
+                    v03_stream_resp.result
+                )
+
+        async for item in self._handle_stream(context, _handler):
+            yield item
+
+    async def CreateTaskPushNotificationConfig(
+        self,
+        request: a2a_v0_3_pb2.CreateTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.TaskPushNotificationConfig:
+        """Handles the 'CreateTaskPushNotificationConfig' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.TaskPushNotificationConfig:
+            req_v03 = types_v03.SetTaskPushNotificationConfigRequest(
+                id=0,
+                params=proto_utils.FromProto.task_push_notification_config_request(
+                    request
+                ),
+            )
+            res_v03 = (
+                await self.handler03.on_create_task_push_notification_config(
+                    req_v03, server_context
+                )
+            )
+            return proto_utils.ToProto.task_push_notification_config(res_v03)
+
+        return await self._handle_unary(
+            context, _handler, a2a_v0_3_pb2.TaskPushNotificationConfig()
+        )
+
+    async def GetTaskPushNotificationConfig(
+        self,
+        request: a2a_v0_3_pb2.GetTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.TaskPushNotificationConfig:
+        """Handles the 'GetTaskPushNotificationConfig' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.TaskPushNotificationConfig:
+            task_id, config_id = self._extract_task_and_config_id(request.name)
+            req_v03 = types_v03.GetTaskPushNotificationConfigRequest(
+                id=0,
+                params=types_v03.GetTaskPushNotificationConfigParams(
+                    id=task_id, push_notification_config_id=config_id
+                ),
+            )
+            res_v03 = await self.handler03.on_get_task_push_notification_config(
+                req_v03, server_context
+            )
+            return proto_utils.ToProto.task_push_notification_config(res_v03)
+
+        return await self._handle_unary(
+            context, _handler, a2a_v0_3_pb2.TaskPushNotificationConfig()
+        )
+
+    async def ListTaskPushNotificationConfig(
+        self,
+        request: a2a_v0_3_pb2.ListTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse:
+        """Handles the 'ListTaskPushNotificationConfig' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse:
+            task_id = self._extract_task_id(request.parent)
+            req_v03 = types_v03.ListTaskPushNotificationConfigRequest(
+                id=0,
+                params=types_v03.ListTaskPushNotificationConfigParams(
+                    id=task_id
+                ),
+            )
+            res_v03 = (
+                await self.handler03.on_list_task_push_notification_configs(
+                    req_v03, server_context
+                )
+            )
+
+            return a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse(
+                configs=[
+                    proto_utils.ToProto.task_push_notification_config(c)
+                    for c in res_v03
+                ]
+            )
+
+        return await self._handle_unary(
+            context,
+            _handler,
+            a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse(),
+        )
+
+    async def GetAgentCard(
+        self,
+        request: a2a_v0_3_pb2.GetAgentCardRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_v0_3_pb2.AgentCard:
+        """Get the extended agent card for the agent served (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_v0_3_pb2.AgentCard:
+            req_v03 = types_v03.GetAuthenticatedExtendedCardRequest(id=0)
+            res_v03 = await self.handler03.on_get_extended_agent_card(
+                req_v03, server_context
+            )
+            return proto_utils.ToProto.agent_card(res_v03)
+
+        return await self._handle_unary(
+            context, _handler, a2a_v0_3_pb2.AgentCard()
+        )
+
+    async def DeleteTaskPushNotificationConfig(
+        self,
+        request: a2a_v0_3_pb2.DeleteTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> empty_pb2.Empty:
+        """Handles the 'DeleteTaskPushNotificationConfig' gRPC method (v0.3)."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> empty_pb2.Empty:
+            task_id, config_id = self._extract_task_and_config_id(request.name)
+            req_v03 = types_v03.DeleteTaskPushNotificationConfigRequest(
+                id=0,
+                params=types_v03.DeleteTaskPushNotificationConfigParams(
+                    id=task_id, push_notification_config_id=config_id
+                ),
+            )
+            await self.handler03.on_delete_task_push_notification_config(
+                req_v03, server_context
+            )
+            return empty_pb2.Empty()
+
+        return await self._handle_unary(context, _handler, empty_pb2.Empty())
diff --git a/src/a2a/compat/v0_3/grpc_transport.py b/src/a2a/compat/v0_3/grpc_transport.py
new file mode 100644
index 000000000..26faaa3d3
--- /dev/null
+++ b/src/a2a/compat/v0_3/grpc_transport.py
@@ -0,0 +1,372 @@
+import logging
+
+from collections.abc import AsyncGenerator, Callable
+from functools import wraps
+from typing import Any, NoReturn
+
+from a2a.client.errors import A2AClientError, A2AClientTimeoutError
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP
+
+
+try:
+    import grpc  # type: ignore[reportMissingModuleSource]
+except ImportError as e:
+    raise ImportError(
+        'A2AGrpcClient requires grpcio and grpcio-tools to be installed. '
+        'Install with: '
+        "'pip install a2a-sdk[grpc]'"
+    ) from e
+
+
+from a2a.client.client import ClientCallContext, ClientConfig
+from a2a.client.optionals import Channel
+from a2a.client.transports.base import ClientTransport
+from a2a.compat.v0_3 import (
+    a2a_v0_3_pb2,
+    a2a_v0_3_pb2_grpc,
+    conversions,
+    proto_utils,
+)
+from a2a.compat.v0_3 import (
+    types as types_v03,
+)
+from a2a.compat.v0_3.extension_headers import add_legacy_extension_header
+from a2a.types import a2a_pb2
+from a2a.utils.constants import PROTOCOL_VERSION_0_3, VERSION_HEADER
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+_A2A_ERROR_NAME_TO_CLS = {
+    error_type.__name__: error_type for error_type in JSON_RPC_ERROR_CODE_MAP
+}
+
+
+def _map_grpc_error(e: grpc.aio.AioRpcError) -> NoReturn:
+    if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
+        raise A2AClientTimeoutError('Client Request timed out') from e
+
+    details = e.details()
+    if isinstance(details, str) and ': ' in details:
+        error_type_name, error_message = details.split(': ', 1)
+        exception_cls = _A2A_ERROR_NAME_TO_CLS.get(error_type_name)
+        if exception_cls:
+            raise exception_cls(error_message) from e
+    raise A2AClientError(f'gRPC Error {e.code().name}: {e.details()}') from e
+
+
+def _handle_grpc_exception(func: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return await func(*args, **kwargs)
+        except grpc.aio.AioRpcError as e:
+            _map_grpc_error(e)
+
+    return wrapper
+
+
+def _handle_grpc_stream_exception(
+    func: Callable[..., Any],
+) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            async for item in func(*args, **kwargs):
+                yield item
+        except grpc.aio.AioRpcError as e:
+            _map_grpc_error(e)
+
+    return wrapper
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class CompatGrpcTransport(ClientTransport):
+    """A backward compatible gRPC transport for A2A v0.3."""
+
+    def __init__(self, channel: Channel, agent_card: a2a_pb2.AgentCard | None):
+        """Initializes the CompatGrpcTransport."""
+        self.agent_card = agent_card
+        self.channel = channel
+        self.stub = a2a_v0_3_pb2_grpc.A2AServiceStub(channel)
+
+    @classmethod
+    def create(
+        cls,
+        card: a2a_pb2.AgentCard,
+        url: str,
+        config: ClientConfig,
+    ) -> 'CompatGrpcTransport':
+        """Creates a gRPC transport for the A2A client."""
+        if config.grpc_channel_factory is None:
+            raise ValueError('grpc_channel_factory is required when using gRPC')
+        return cls(config.grpc_channel_factory(url), card)
+
+    @_handle_grpc_exception
+    async def send_message(
+        self,
+        request: a2a_pb2.SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.SendMessageResponse:
+        """Sends a non-streaming message request to the agent (v0.3)."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+        req_proto = a2a_v0_3_pb2.SendMessageRequest(
+            request=proto_utils.ToProto.message(req_v03.params.message),
+            configuration=proto_utils.ToProto.message_send_configuration(
+                req_v03.params.configuration
+            ),
+            metadata=proto_utils.ToProto.metadata(req_v03.params.metadata),
+        )
+
+        resp_proto = await self.stub.SendMessage(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+
+        which = resp_proto.WhichOneof('payload')
+        if which == 'task':
+            return a2a_pb2.SendMessageResponse(
+                task=conversions.to_core_task(
+                    proto_utils.FromProto.task(resp_proto.task)
+                )
+            )
+        if which == 'msg':
+            return a2a_pb2.SendMessageResponse(
+                message=conversions.to_core_message(
+                    proto_utils.FromProto.message(resp_proto.msg)
+                )
+            )
+        return a2a_pb2.SendMessageResponse()
+
+    @_handle_grpc_stream_exception
+    async def send_message_streaming(
+        self,
+        request: a2a_pb2.SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[a2a_pb2.StreamResponse]:
+        """Sends a streaming message request to the agent (v0.3)."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+        req_proto = a2a_v0_3_pb2.SendMessageRequest(
+            request=proto_utils.ToProto.message(req_v03.params.message),
+            configuration=proto_utils.ToProto.message_send_configuration(
+                req_v03.params.configuration
+            ),
+            metadata=proto_utils.ToProto.metadata(req_v03.params.metadata),
+        )
+
+        stream = self.stub.SendStreamingMessage(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        while True:
+            response = await stream.read()
+            if response == grpc.aio.EOF:  # type: ignore[attr-defined]
+                break
+            yield conversions.to_core_stream_response(
+                types_v03.SendStreamingMessageSuccessResponse(
+                    result=proto_utils.FromProto.stream_response(response)
+                )
+            )
+
+    @_handle_grpc_stream_exception
+    async def subscribe(
+        self,
+        request: a2a_pb2.SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[a2a_pb2.StreamResponse]:
+        """Reconnects to get task updates (v0.3)."""
+        req_proto = a2a_v0_3_pb2.TaskSubscriptionRequest(
+            name=f'tasks/{request.id}'
+        )
+
+        stream = self.stub.TaskSubscription(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        while True:
+            response = await stream.read()
+            if response == grpc.aio.EOF:  # type: ignore[attr-defined]
+                break
+            yield conversions.to_core_stream_response(
+                types_v03.SendStreamingMessageSuccessResponse(
+                    result=proto_utils.FromProto.stream_response(response)
+                )
+            )
+
+    @_handle_grpc_exception
+    async def get_task(
+        self,
+        request: a2a_pb2.GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.Task:
+        """Retrieves the current state and history of a specific task (v0.3)."""
+        req_proto = a2a_v0_3_pb2.GetTaskRequest(
+            name=f'tasks/{request.id}',
+            history_length=request.history_length,
+        )
+        resp_proto = await self.stub.GetTask(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        return conversions.to_core_task(proto_utils.FromProto.task(resp_proto))
+
+    @_handle_grpc_exception
+    async def list_tasks(
+        self,
+        request: a2a_pb2.ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.ListTasksResponse:
+        """Retrieves tasks for an agent (v0.3 - NOT SUPPORTED in v0.3)."""
+        # v0.3 proto doesn't have ListTasks.
+        raise NotImplementedError(
+            'ListTasks is not supported in A2A v0.3 gRPC.'
+        )
+
+    @_handle_grpc_exception
+    async def cancel_task(
+        self,
+        request: a2a_pb2.CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.Task:
+        """Requests the agent to cancel a specific task (v0.3)."""
+        req_proto = a2a_v0_3_pb2.CancelTaskRequest(name=f'tasks/{request.id}')
+        resp_proto = await self.stub.CancelTask(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        return conversions.to_core_task(proto_utils.FromProto.task(resp_proto))
+
+    @_handle_grpc_exception
+    async def create_task_push_notification_config(
+        self,
+        request: a2a_pb2.TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration (v0.3)."""
+        req_v03 = (
+            conversions.to_compat_create_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        req_proto = a2a_v0_3_pb2.CreateTaskPushNotificationConfigRequest(
+            parent=f'tasks/{request.task_id}',
+            config_id=req_v03.params.push_notification_config.id,
+            config=proto_utils.ToProto.task_push_notification_config(
+                req_v03.params
+            ),
+        )
+        resp_proto = await self.stub.CreateTaskPushNotificationConfig(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        return conversions.to_core_task_push_notification_config(
+            proto_utils.FromProto.task_push_notification_config(resp_proto)
+        )
+
+    @_handle_grpc_exception
+    async def get_task_push_notification_config(
+        self,
+        request: a2a_pb2.GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.TaskPushNotificationConfig:
+        """Retrieves the push notification configuration (v0.3)."""
+        req_proto = a2a_v0_3_pb2.GetTaskPushNotificationConfigRequest(
+            name=f'tasks/{request.task_id}/pushNotificationConfigs/{request.id}'
+        )
+        resp_proto = await self.stub.GetTaskPushNotificationConfig(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        return conversions.to_core_task_push_notification_config(
+            proto_utils.FromProto.task_push_notification_config(resp_proto)
+        )
+
+    @_handle_grpc_exception
+    async def list_task_push_notification_configs(
+        self,
+        request: a2a_pb2.ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task (v0.3)."""
+        req_proto = a2a_v0_3_pb2.ListTaskPushNotificationConfigRequest(
+            parent=f'tasks/{request.task_id}'
+        )
+        resp_proto = await self.stub.ListTaskPushNotificationConfig(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        return conversions.to_core_list_task_push_notification_config_response(
+            proto_utils.FromProto.list_task_push_notification_config_response(
+                resp_proto
+            )
+        )
+
+    @_handle_grpc_exception
+    async def delete_task_push_notification_config(
+        self,
+        request: a2a_pb2.DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration (v0.3)."""
+        req_proto = a2a_v0_3_pb2.DeleteTaskPushNotificationConfigRequest(
+            name=f'tasks/{request.task_id}/pushNotificationConfigs/{request.id}'
+        )
+        await self.stub.DeleteTaskPushNotificationConfig(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+
+    @_handle_grpc_exception
+    async def get_extended_agent_card(
+        self,
+        request: a2a_pb2.GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> a2a_pb2.AgentCard:
+        """Retrieves the agent's card (v0.3)."""
+        req_proto = a2a_v0_3_pb2.GetAgentCardRequest()
+        resp_proto = await self.stub.GetAgentCard(
+            req_proto,
+            metadata=self._get_grpc_metadata(context),
+        )
+        card = conversions.to_core_agent_card(
+            proto_utils.FromProto.agent_card(resp_proto)
+        )
+
+        self.agent_card = card
+        return card
+
+    async def close(self) -> None:
+        """Closes the gRPC channel."""
+        await self.channel.close()
+
+    def _get_grpc_metadata(
+        self, context: ClientCallContext | None = None
+    ) -> list[tuple[str, str]]:
+        """Creates gRPC metadata for extensions."""
+        metadata: list[tuple[str, str]] = [
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_0_3)
+        ]
+
+        if context and context.service_parameters:
+            params = dict(context.service_parameters)
+            add_legacy_extension_header(params)
+            for key, value in params.items():
+                metadata.append((key.lower(), value))
+
+        return metadata
diff --git a/src/a2a/compat/v0_3/jsonrpc_adapter.py b/src/a2a/compat/v0_3/jsonrpc_adapter.py
new file mode 100644
index 000000000..2263f336b
--- /dev/null
+++ b/src/a2a/compat/v0_3/jsonrpc_adapter.py
@@ -0,0 +1,328 @@
+import logging
+
+from collections.abc import AsyncIterable, AsyncIterator
+from typing import TYPE_CHECKING, Any, get_args
+
+from sse_starlette.sse import EventSourceResponse
+from starlette.responses import JSONResponse
+
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+
+    from a2a.server.request_handlers.request_handler import RequestHandler
+
+    _package_starlette_installed = True
+else:
+    try:
+        from starlette.requests import Request
+
+        _package_starlette_installed = True
+    except ImportError:
+        Request = Any
+
+        _package_starlette_installed = False
+
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.context_builders import V03ServerCallContextBuilder
+from a2a.compat.v0_3.request_handler import RequestHandler03
+from a2a.server.context import ServerCallContext
+from a2a.server.jsonrpc_models import (
+    InternalError as CoreInternalError,
+)
+from a2a.server.jsonrpc_models import (
+    InvalidParamsError as CoreInvalidParamsError,
+)
+from a2a.server.jsonrpc_models import (
+    JSONRPCError as CoreJSONRPCError,
+)
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    ServerCallContextBuilder,
+    create_event_source_response,
+)
+from a2a.utils import constants
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP, A2AError
+from a2a.utils.version_validator import validate_version
+
+
+logger = logging.getLogger(__name__)
+
+
+class JSONRPC03Adapter:
+    """Adapter to make RequestHandler work with v0.3 JSONRPC API."""
+
+    METHOD_TO_MODEL = {
+        'message/send': types_v03.SendMessageRequest,
+        'message/stream': types_v03.SendStreamingMessageRequest,
+        'tasks/get': types_v03.GetTaskRequest,
+        'tasks/cancel': types_v03.CancelTaskRequest,
+        'tasks/pushNotificationConfig/set': types_v03.SetTaskPushNotificationConfigRequest,
+        'tasks/pushNotificationConfig/get': types_v03.GetTaskPushNotificationConfigRequest,
+        'tasks/pushNotificationConfig/list': types_v03.ListTaskPushNotificationConfigRequest,
+        'tasks/pushNotificationConfig/delete': types_v03.DeleteTaskPushNotificationConfigRequest,
+        'tasks/resubscribe': types_v03.TaskResubscriptionRequest,
+        'agent/getAuthenticatedExtendedCard': types_v03.GetAuthenticatedExtendedCardRequest,
+    }
+
+    def __init__(
+        self,
+        http_handler: 'RequestHandler',
+        context_builder: 'ServerCallContextBuilder | None' = None,
+        shutdown_grace_period: float = 0,
+    ) -> None:
+        self.handler = RequestHandler03(
+            request_handler=http_handler,
+        )
+        self._context_builder = V03ServerCallContextBuilder(
+            context_builder or DefaultServerCallContextBuilder()
+        )
+        self._shutdown_grace_period = shutdown_grace_period
+
+    def supports_method(self, method: str) -> bool:
+        """Returns True if the v0.3 adapter supports the given method name."""
+        return method in self.METHOD_TO_MODEL
+
+    def _generate_error_response(
+        self,
+        request_id: 'str | int | None',
+        error: 'Exception | CoreJSONRPCError',
+    ) -> JSONResponse:
+        if isinstance(error, CoreJSONRPCError):
+            err_dict = error.model_dump(by_alias=True)
+            return JSONResponse(
+                {'jsonrpc': '2.0', 'id': request_id, 'error': err_dict}
+            )
+
+        if isinstance(error, A2AError):
+            err_dict = _to_v03_jsonrpc_error(error).model_dump(by_alias=True)
+            return JSONResponse(
+                {'jsonrpc': '2.0', 'id': request_id, 'error': err_dict}
+            )
+
+        internal_error = CoreInternalError(message=str(error))
+        return JSONResponse(
+            {
+                'jsonrpc': '2.0',
+                'id': request_id,
+                'error': internal_error.model_dump(by_alias=True),
+            }
+        )
+
+    async def handle_request(
+        self,
+        request_id: 'str | int | None',
+        method: str,
+        body: dict,
+        request: Request,
+    ) -> 'JSONResponse | EventSourceResponse':
+        """Handles v0.3 specific JSON-RPC requests."""
+        try:
+            model_class = self.METHOD_TO_MODEL[method]
+            try:
+                specific_request = model_class.model_validate(body)  # type: ignore[attr-defined]
+            except Exception as e:
+                logger.exception(
+                    'Failed to validate base JSON-RPC request for v0.3'
+                )
+
+                return self._generate_error_response(
+                    request_id,
+                    CoreInvalidParamsError(data=str(e)),
+                )
+
+            call_context = self._context_builder.build(request)
+            call_context.tenant = (
+                getattr(specific_request.params, 'tenant', '')
+                if hasattr(specific_request, 'params')
+                else getattr(specific_request, 'tenant', '')
+            )
+            call_context.state['method'] = method
+            call_context.state['request_id'] = request_id
+
+            if method in ('message/stream', 'tasks/resubscribe'):
+                return await self._process_streaming_request(
+                    request_id, specific_request, call_context
+                )
+
+            return await self._process_non_streaming_request(
+                request_id, specific_request, call_context
+            )
+        except A2AError as e:
+            return self._generate_error_response(request_id, e)
+        except Exception as e:
+            logger.exception('Unhandled exception in v0.3 JSONRPCAdapter')
+            return self._generate_error_response(
+                request_id, CoreInternalError(message=str(e))
+            )
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def _process_non_streaming_request(
+        self,
+        request_id: 'str | int | None',
+        request_obj: Any,
+        context: ServerCallContext,
+    ) -> JSONResponse:
+        method = request_obj.method
+        result: Any
+        if method == 'message/send':
+            res_msg = await self.handler.on_message_send(request_obj, context)
+            result = types_v03.SendMessageResponse(
+                root=types_v03.SendMessageSuccessResponse(
+                    id=request_id, result=res_msg
+                )
+            )
+        elif method == 'tasks/get':
+            res_get = await self.handler.on_get_task(request_obj, context)
+            result = types_v03.GetTaskResponse(
+                root=types_v03.GetTaskSuccessResponse(
+                    id=request_id, result=res_get
+                )
+            )
+        elif method == 'tasks/cancel':
+            res_cancel = await self.handler.on_cancel_task(request_obj, context)
+            result = types_v03.CancelTaskResponse(
+                root=types_v03.CancelTaskSuccessResponse(
+                    id=request_id, result=res_cancel
+                )
+            )
+        elif method == 'tasks/pushNotificationConfig/get':
+            res_get_push = (
+                await self.handler.on_get_task_push_notification_config(
+                    request_obj, context
+                )
+            )
+            result = types_v03.GetTaskPushNotificationConfigResponse(
+                root=types_v03.GetTaskPushNotificationConfigSuccessResponse(
+                    id=request_id, result=res_get_push
+                )
+            )
+        elif method == 'tasks/pushNotificationConfig/set':
+            res_set_push = (
+                await self.handler.on_create_task_push_notification_config(
+                    request_obj, context
+                )
+            )
+            result = types_v03.SetTaskPushNotificationConfigResponse(
+                root=types_v03.SetTaskPushNotificationConfigSuccessResponse(
+                    id=request_id, result=res_set_push
+                )
+            )
+        elif method == 'tasks/pushNotificationConfig/list':
+            res_list_push = (
+                await self.handler.on_list_task_push_notification_configs(
+                    request_obj, context
+                )
+            )
+            result = types_v03.ListTaskPushNotificationConfigResponse(
+                root=types_v03.ListTaskPushNotificationConfigSuccessResponse(
+                    id=request_id, result=res_list_push
+                )
+            )
+        elif method == 'tasks/pushNotificationConfig/delete':
+            await self.handler.on_delete_task_push_notification_config(
+                request_obj, context
+            )
+            result = types_v03.DeleteTaskPushNotificationConfigResponse(
+                root=types_v03.DeleteTaskPushNotificationConfigSuccessResponse(
+                    id=request_id, result=None
+                )
+            )
+        elif method == 'agent/getAuthenticatedExtendedCard':
+            res_card = await self.handler.on_get_extended_agent_card(
+                request_obj, context
+            )
+            result = types_v03.GetAuthenticatedExtendedCardResponse(
+                root=types_v03.GetAuthenticatedExtendedCardSuccessResponse(
+                    id=request_id, result=res_card
+                )
+            )
+        else:
+            raise ValueError(f'Unsupported method {method}')
+
+        return JSONResponse(
+            content=result.model_dump(
+                mode='json', by_alias=True, exclude_none=True
+            )
+        )
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def _process_streaming_request(
+        self,
+        request_id: 'str | int | None',
+        request_obj: Any,
+        context: ServerCallContext,
+    ) -> EventSourceResponse:
+        method = request_obj.method
+        if method == 'message/stream':
+            stream_gen = self.handler.on_message_send_stream(
+                request_obj, context
+            )
+        elif method == 'tasks/resubscribe':
+            stream_gen = self.handler.on_subscribe_to_task(request_obj, context)
+        else:
+            raise ValueError(f'Unsupported streaming method {method}')
+
+        async def event_generator(
+            stream: AsyncIterable[Any],
+        ) -> AsyncIterator[dict[str, str]]:
+            try:
+                async for item in stream:
+                    yield {
+                        'data': item.model_dump_json(
+                            by_alias=True, exclude_none=True
+                        )
+                    }
+            except A2AError as e:
+                err_resp = types_v03.SendStreamingMessageResponse(
+                    root=types_v03.JSONRPCErrorResponse(
+                        id=request_id, error=_to_v03_jsonrpc_error(e)
+                    )
+                )
+                yield {
+                    'data': err_resp.model_dump_json(
+                        by_alias=True, exclude_none=True
+                    )
+                }
+            except Exception as e:
+                logger.exception(
+                    'Error during stream generation in v0.3 JSONRPCAdapter'
+                )
+                err = types_v03.InternalError(message=str(e))
+                err_resp = types_v03.SendStreamingMessageResponse(
+                    root=types_v03.JSONRPCErrorResponse(
+                        id=request_id, error=err
+                    )
+                )
+                yield {
+                    'data': err_resp.model_dump_json(
+                        by_alias=True, exclude_none=True
+                    )
+                }
+
+        return create_event_source_response(
+            event_generator(stream_gen),
+            shutdown_grace_period=self._shutdown_grace_period,
+        )
+
+
+# Error codes defined by the A2A v0.3 specification, derived from the v0.3
+# error models. Codes added in v1.0 (e.g. -32009 VersionNotSupported) are
+# unknown to v0.3 clients.
+_V03_ERROR_CODES = frozenset(
+    cls.model_fields['code'].default
+    for cls in get_args(types_v03.A2AError.model_fields['root'].annotation)
+)
+
+
+def _to_v03_jsonrpc_error(error: A2AError) -> types_v03.JSONRPCError:
+    """Maps an A2AError to a v0.3 JSON-RPC error carrying its A2A error code.
+
+    Errors without a v0.3 equivalent are reported as InternalError (-32603).
+    """
+    code = JSON_RPC_ERROR_CODE_MAP.get(type(error), -32603)
+    if code not in _V03_ERROR_CODES:
+        code = -32603
+    return types_v03.JSONRPCError(
+        code=code, message=error.message, data=error.data
+    )
diff --git a/src/a2a/compat/v0_3/jsonrpc_transport.py b/src/a2a/compat/v0_3/jsonrpc_transport.py
new file mode 100644
index 000000000..9e83168a1
--- /dev/null
+++ b/src/a2a/compat/v0_3/jsonrpc_transport.py
@@ -0,0 +1,512 @@
+import json
+import logging
+
+from collections.abc import AsyncGenerator
+from typing import Any, NoReturn
+from uuid import uuid4
+
+import httpx
+
+from jsonrpc.jsonrpc2 import JSONRPC20Request, JSONRPC20Response
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.http_helpers import (
+    get_http_args,
+    send_http_request,
+    send_http_stream_request,
+)
+from a2a.compat.v0_3 import conversions
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.extension_headers import add_legacy_extension_header
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.constants import PROTOCOL_VERSION_0_3, VERSION_HEADER
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+_JSON_RPC_ERROR_CODE_TO_A2A_ERROR = {
+    code: error_type for error_type, code in JSON_RPC_ERROR_CODE_MAP.items()
+}
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class CompatJsonRpcTransport(ClientTransport):
+    """A backward compatible JSON-RPC transport for A2A v0.3."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        agent_card: AgentCard | None,
+        url: str,
+        *,
+        is_shared_httpx: bool = False,
+    ):
+        """Initializes the CompatJsonRpcTransport."""
+        self.url = url
+        self.httpx_client = httpx_client
+        self.agent_card = agent_card
+        self.is_shared_httpx = is_shared_httpx
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+
+        rpc_request = JSONRPC20Request(
+            method='message/send',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        result_dict = json_rpc_response.result
+        if not isinstance(result_dict, dict):
+            return SendMessageResponse()
+
+        kind = result_dict.get('kind')
+
+        # Fallback for old servers that might omit kind
+        if not kind:
+            if 'messageId' in result_dict:
+                kind = 'message'
+            elif 'id' in result_dict:
+                kind = 'task'
+
+        if kind == 'task':
+            return SendMessageResponse(
+                task=conversions.to_core_task(
+                    types_v03.Task.model_validate(result_dict)
+                )
+            )
+        if kind == 'message':
+            return SendMessageResponse(
+                message=conversions.to_core_message(
+                    types_v03.Message.model_validate(result_dict)
+                )
+            )
+
+        return SendMessageResponse()
+
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+
+        rpc_request = JSONRPC20Request(
+            method='message/stream',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        async for event in self._send_stream_request(
+            dict(rpc_request.data),
+            context,
+        ):
+            yield event
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        req_v03 = conversions.to_compat_get_task_request(request, request_id=0)
+
+        rpc_request = JSONRPC20Request(
+            method='tasks/get',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+        return conversions.to_core_task(
+            types_v03.Task.model_validate(json_rpc_response.result)
+        )
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        raise NotImplementedError(
+            'ListTasks is not supported in A2A v0.3 JSONRPC.'
+        )
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        req_v03 = conversions.to_compat_cancel_task_request(
+            request, request_id=0
+        )
+
+        rpc_request = JSONRPC20Request(
+            method='tasks/cancel',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        return conversions.to_core_task(
+            types_v03.Task.model_validate(json_rpc_response.result)
+        )
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        req_v03 = (
+            conversions.to_compat_create_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        rpc_request = JSONRPC20Request(
+            method='tasks/pushNotificationConfig/set',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        return conversions.to_core_task_push_notification_config(
+            types_v03.TaskPushNotificationConfig.model_validate(
+                json_rpc_response.result
+            )
+        )
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        req_v03 = (
+            conversions.to_compat_get_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        rpc_request = JSONRPC20Request(
+            method='tasks/pushNotificationConfig/get',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        return conversions.to_core_task_push_notification_config(
+            types_v03.TaskPushNotificationConfig.model_validate(
+                json_rpc_response.result
+            )
+        )
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        req_v03 = (
+            conversions.to_compat_list_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        rpc_request = JSONRPC20Request(
+            method='tasks/pushNotificationConfig/list',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        configs_data = json_rpc_response.result
+        if not isinstance(configs_data, list):
+            return ListTaskPushNotificationConfigsResponse()
+
+        response = ListTaskPushNotificationConfigsResponse()
+        for config_data in configs_data:
+            response.configs.append(
+                conversions.to_core_task_push_notification_config(
+                    types_v03.TaskPushNotificationConfig.model_validate(
+                        config_data
+                    )
+                )
+            )
+        return response
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        req_v03 = (
+            conversions.to_compat_delete_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        rpc_request = JSONRPC20Request(
+            method='tasks/pushNotificationConfig/delete',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        if 'result' not in response_data and 'error' not in response_data:
+            response_data['result'] = None
+
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates."""
+        req_v03 = conversions.to_compat_subscribe_to_task_request(
+            request, request_id=0
+        )
+        rpc_request = JSONRPC20Request(
+            method='tasks/resubscribe',
+            params=req_v03.params.model_dump(
+                by_alias=True, exclude_none=True, mode='json'
+            ),
+            _id=str(uuid4()),
+        )
+        async for event in self._send_stream_request(
+            dict(rpc_request.data),
+            context,
+        ):
+            yield event
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the Extended AgentCard."""
+        card = self.agent_card
+        if card and not card.capabilities.extended_agent_card:
+            return card
+
+        rpc_request = JSONRPC20Request(
+            method='agent/getAuthenticatedExtendedCard',
+            params={},
+            _id=str(uuid4()),
+        )
+        response_data = await self._send_request(
+            dict(rpc_request.data), context
+        )
+        json_rpc_response = JSONRPC20Response(**response_data)
+        if json_rpc_response.error:
+            raise self._create_jsonrpc_error(json_rpc_response.error)
+
+        card = conversions.to_core_agent_card(
+            types_v03.AgentCard.model_validate(json_rpc_response.result)
+        )
+        self.agent_card = card
+        return card
+
+    async def close(self) -> None:
+        """Closes the httpx client unless it is shared."""
+        if self.is_shared_httpx:
+            logger.debug(
+                'Cannot close a shared httpx client; only the provider '
+                'that supplied it via ClientConfig.httpx_client can close it.'
+            )
+            return
+        if self.httpx_client.is_closed:
+            raise A2AClientError('HTTP client is already closed')
+        try:
+            await self.httpx_client.aclose()
+        except Exception as e:
+            raise A2AClientError(f'Failed to close HTTP client: {e}') from e
+
+    def _create_jsonrpc_error(self, error_dict: dict[str, Any]) -> Exception:
+        """Raises a specific error based on jsonrpc error code."""
+        code = error_dict.get('code')
+        message = error_dict.get('message', 'Unknown Error')
+
+        if isinstance(code, int):
+            error_class = _JSON_RPC_ERROR_CODE_TO_A2A_ERROR.get(code)
+            if error_class:
+                return error_class(message)
+
+        return A2AClientError(message)
+
+    def _handle_http_error(self, e: httpx.HTTPStatusError) -> NoReturn:
+        """Handles HTTP errors for standard requests."""
+        raise A2AClientError(f'HTTP Error: {e.response.status_code}') from e
+
+    async def _send_stream_request(
+        self,
+        json_data: dict[str, Any],
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends an HTTP stream request."""
+        http_kwargs = get_http_args(context)
+        http_kwargs.setdefault('headers', {})
+        http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3
+        add_legacy_extension_header(http_kwargs['headers'])
+
+        async for sse_data in send_http_stream_request(
+            self.httpx_client,
+            'POST',
+            self.url,
+            self._handle_http_error,
+            json=json_data,
+            **http_kwargs,
+        ):
+            data = json.loads(sse_data)
+            if 'error' in data:
+                raise self._create_jsonrpc_error(data['error'])
+
+            result_dict = data.get('result', {})
+            if not isinstance(result_dict, dict):
+                continue
+
+            kind = result_dict.get('kind')
+
+            if not kind:
+                if 'taskId' in result_dict and 'final' in result_dict:
+                    kind = 'status-update'
+                elif 'messageId' in result_dict:
+                    kind = 'message'
+                elif 'id' in result_dict:
+                    kind = 'task'
+
+            result: (
+                types_v03.Task
+                | types_v03.Message
+                | types_v03.TaskStatusUpdateEvent
+                | types_v03.TaskArtifactUpdateEvent
+            )
+            if kind == 'task':
+                result = types_v03.Task.model_validate(result_dict)
+            elif kind == 'message':
+                result = types_v03.Message.model_validate(result_dict)
+            elif kind == 'status-update':
+                result = types_v03.TaskStatusUpdateEvent.model_validate(
+                    result_dict
+                )
+            elif kind == 'artifact-update':
+                result = types_v03.TaskArtifactUpdateEvent.model_validate(
+                    result_dict
+                )
+            else:
+                continue
+
+            yield conversions.to_core_stream_response(
+                types_v03.SendStreamingMessageSuccessResponse(result=result)
+            )
+
+    async def _send_request(
+        self,
+        json_data: dict[str, Any],
+        context: ClientCallContext | None = None,
+    ) -> dict[str, Any]:
+        """Sends an HTTP request."""
+        http_kwargs = get_http_args(context)
+        http_kwargs.setdefault('headers', {})
+        http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3
+        add_legacy_extension_header(http_kwargs['headers'])
+
+        request = self.httpx_client.build_request(
+            'POST',
+            self.url,
+            json=json_data,
+            **http_kwargs,
+        )
+        return await send_http_request(
+            self.httpx_client, request, self._handle_http_error
+        )
diff --git a/src/a2a/compat/v0_3/model_conversions.py b/src/a2a/compat/v0_3/model_conversions.py
new file mode 100644
index 000000000..db8e43318
--- /dev/null
+++ b/src/a2a/compat/v0_3/model_conversions.py
@@ -0,0 +1,97 @@
+"""Database model conversions for v0.3 compatibility."""
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from cryptography.fernet import Fernet
+
+
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.conversions import (
+    to_compat_push_notification_config,
+    to_compat_task,
+    to_core_task,
+    to_core_task_push_notification_config,
+)
+from a2a.server.models import PushNotificationConfigModel, TaskModel
+from a2a.types import a2a_pb2 as pb2_v10
+
+
+def core_to_compat_task_model(task: pb2_v10.Task, owner: str) -> TaskModel:
+    """Converts a 1.0 core Task to a TaskModel using v0.3 JSON structure."""
+    compat_task = to_compat_task(task)
+    data = compat_task.model_dump(mode='json')
+
+    return TaskModel(
+        id=task.id,
+        context_id=task.context_id,
+        owner=owner,
+        status=data.get('status'),
+        history=data.get('history'),
+        artifacts=data.get('artifacts'),
+        task_metadata=data.get('metadata'),
+        protocol_version='0.3',
+        last_updated=(
+            task.status.timestamp.ToDatetime()
+            if task.status.HasField('timestamp')
+            else None
+        ),
+    )
+
+
+def compat_task_model_to_core(task_model: TaskModel) -> pb2_v10.Task:
+    """Converts a TaskModel with v0.3 structure to a 1.0 core Task."""
+    compat_task = types_v03.Task(
+        id=task_model.id,
+        context_id=task_model.context_id,
+        status=types_v03.TaskStatus.model_validate(task_model.status),
+        artifacts=(
+            [types_v03.Artifact.model_validate(a) for a in task_model.artifacts]
+            if task_model.artifacts
+            else []
+        ),
+        history=(
+            [types_v03.Message.model_validate(h) for h in task_model.history]
+            if task_model.history
+            else []
+        ),
+        metadata=task_model.task_metadata,
+    )
+    return to_core_task(compat_task)
+
+
+def core_to_compat_push_notification_config_model(
+    task_id: str,
+    config: pb2_v10.TaskPushNotificationConfig,
+    owner: str,
+    fernet: 'Fernet | None' = None,
+) -> PushNotificationConfigModel:
+    """Converts a 1.0 core TaskPushNotificationConfig to a PushNotificationConfigModel using v0.3 JSON structure."""
+    compat_config = to_compat_push_notification_config(config)
+
+    json_payload = compat_config.model_dump_json().encode('utf-8')
+    data_to_store = fernet.encrypt(json_payload) if fernet else json_payload
+
+    return PushNotificationConfigModel(
+        task_id=task_id,
+        config_id=config.id,
+        owner=owner,
+        config_data=data_to_store,
+        protocol_version='0.3',
+    )
+
+
+def compat_push_notification_config_model_to_core(
+    model_instance: str, task_id: str
+) -> pb2_v10.TaskPushNotificationConfig:
+    """Converts a PushNotificationConfigModel with v0.3 structure back to a 1.0 core TaskPushNotificationConfig."""
+    inner_config = types_v03.PushNotificationConfig.model_validate_json(
+        model_instance
+    )
+    return to_core_task_push_notification_config(
+        types_v03.TaskPushNotificationConfig(
+            task_id=task_id,
+            push_notification_config=inner_config,
+        )
+    )
diff --git a/src/a2a/compat/v0_3/proto_utils.py b/src/a2a/compat/v0_3/proto_utils.py
new file mode 100644
index 000000000..14fb3ace9
--- /dev/null
+++ b/src/a2a/compat/v0_3/proto_utils.py
@@ -0,0 +1,1128 @@
+# mypy: disable-error-code="arg-type"
+"""This file was migrated from the a2a-python SDK version 0.3.
+
+It provides utilities for converting between legacy v0.3 Pydantic models and legacy v0.3 Protobuf definitions.
+"""
+
+import json
+import logging
+import re
+
+from typing import Any
+
+from google.protobuf import json_format, struct_pb2
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2 as a2a_pb2
+from a2a.compat.v0_3 import types
+from a2a.utils.errors import InvalidParamsError
+
+
+logger = logging.getLogger(__name__)
+
+
+# Regexp patterns for matching
+TASK_NAME_MATCH = re.compile(r'tasks/([^/]+)')
+TASK_PUSH_CONFIG_NAME_MATCH = re.compile(
+    r'tasks/([^/]+)/pushNotificationConfigs/([^/]+)'
+)
+
+
+def dict_to_struct(dictionary: dict[str, Any]) -> struct_pb2.Struct:
+    """Converts a Python dict to a Struct proto.
+
+    Unfortunately, using `json_format.ParseDict` does not work because this
+    wants the dictionary to be an exact match of the Struct proto with fields
+    and keys and values, not the traditional Python dict structure.
+
+    Args:
+      dictionary: The Python dict to convert.
+
+    Returns:
+      The Struct proto.
+    """
+    struct = struct_pb2.Struct()
+    for key, val in dictionary.items():
+        if isinstance(val, dict):
+            struct[key] = dict_to_struct(val)
+        else:
+            struct[key] = val
+    return struct
+
+
+def make_dict_serializable(value: Any) -> Any:
+    """Dict pre-processing utility: converts non-serializable values to serializable form.
+
+    Use this when you want to normalize a dictionary before dict->Struct conversion.
+
+    Args:
+        value: The value to convert.
+
+    Returns:
+        A serializable value.
+    """
+    if isinstance(value, str | int | float | bool) or value is None:
+        return value
+    if isinstance(value, dict):
+        return {k: make_dict_serializable(v) for k, v in value.items()}
+    if isinstance(value, list | tuple):
+        return [make_dict_serializable(item) for item in value]
+    return str(value)
+
+
+def normalize_large_integers_to_strings(
+    value: Any, max_safe_digits: int = 15
+) -> Any:
+    """Integer preprocessing utility: converts large integers to strings.
+
+    Use this when you want to convert large integers to strings considering
+    JavaScript's MAX_SAFE_INTEGER (2^53 - 1) limitation.
+
+    Args:
+        value: The value to convert.
+        max_safe_digits: Maximum safe integer digits (default: 15).
+
+    Returns:
+        A normalized value.
+    """
+    max_safe_int = 10**max_safe_digits - 1
+
+    def _normalize(item: Any) -> Any:
+        if isinstance(item, int) and abs(item) > max_safe_int:
+            return str(item)
+        if isinstance(item, dict):
+            return {k: _normalize(v) for k, v in item.items()}
+        if isinstance(item, list | tuple):
+            return [_normalize(i) for i in item]
+        return item
+
+    return _normalize(value)
+
+
+def parse_string_integers_in_dict(value: Any, max_safe_digits: int = 15) -> Any:
+    """String post-processing utility: converts large integer strings back to integers.
+
+    Use this when you want to restore large integer strings to integers
+    after Struct->dict conversion.
+
+    Args:
+        value: The value to convert.
+        max_safe_digits: Maximum safe integer digits (default: 15).
+
+    Returns:
+        A parsed value.
+    """
+    if isinstance(value, dict):
+        return {
+            k: parse_string_integers_in_dict(v, max_safe_digits)
+            for k, v in value.items()
+        }
+    if isinstance(value, list | tuple):
+        return [
+            parse_string_integers_in_dict(item, max_safe_digits)
+            for item in value
+        ]
+    if isinstance(value, str):
+        # Handle potential negative numbers.
+        stripped_value = value.lstrip('-')
+        if stripped_value.isdigit() and len(stripped_value) > max_safe_digits:
+            return int(value)
+    return value
+
+
+class ToProto:
+    """Converts Python types to proto types."""
+
+    @classmethod
+    def message(cls, message: types.Message | None) -> a2a_pb2.Message | None:
+        if message is None:
+            return None
+        return a2a_pb2.Message(
+            message_id=message.message_id,
+            content=[cls.part(p) for p in message.parts],
+            context_id=message.context_id or '',
+            task_id=message.task_id or '',
+            role=cls.role(message.role),
+            metadata=cls.metadata(message.metadata),
+            extensions=message.extensions or [],
+        )
+
+    @classmethod
+    def metadata(
+        cls, metadata: dict[str, Any] | None
+    ) -> struct_pb2.Struct | None:
+        if metadata is None:
+            return None
+        return dict_to_struct(metadata)
+
+    @classmethod
+    def part(cls, part: types.Part) -> a2a_pb2.Part:
+        if isinstance(part.root, types.TextPart):
+            return a2a_pb2.Part(
+                text=part.root.text, metadata=cls.metadata(part.root.metadata)
+            )
+        if isinstance(part.root, types.FilePart):
+            return a2a_pb2.Part(
+                file=cls.file(part.root.file),
+                metadata=cls.metadata(part.root.metadata),
+            )
+        if isinstance(part.root, types.DataPart):
+            return a2a_pb2.Part(
+                data=cls.data(part.root.data),
+                metadata=cls.metadata(part.root.metadata),
+            )
+        raise ValueError(f'Unsupported part type: {part.root}')
+
+    @classmethod
+    def data(cls, data: dict[str, Any]) -> a2a_pb2.DataPart:
+        return a2a_pb2.DataPart(data=dict_to_struct(data))
+
+    @classmethod
+    def file(
+        cls, file: types.FileWithUri | types.FileWithBytes
+    ) -> a2a_pb2.FilePart:
+        if isinstance(file, types.FileWithUri):
+            return a2a_pb2.FilePart(
+                file_with_uri=file.uri, mime_type=file.mime_type, name=file.name
+            )
+        return a2a_pb2.FilePart(
+            file_with_bytes=file.bytes.encode('utf-8'),
+            mime_type=file.mime_type,
+            name=file.name,
+        )
+
+    @classmethod
+    def task(cls, task: types.Task) -> a2a_pb2.Task:
+        return a2a_pb2.Task(
+            id=task.id,
+            context_id=task.context_id,
+            status=cls.task_status(task.status),
+            artifacts=(
+                [cls.artifact(a) for a in task.artifacts]
+                if task.artifacts
+                else None
+            ),
+            history=(
+                [cls.message(h) for h in task.history]  # type: ignore[misc]
+                if task.history
+                else None
+            ),
+            metadata=cls.metadata(task.metadata),
+        )
+
+    @classmethod
+    def task_status(cls, status: types.TaskStatus) -> a2a_pb2.TaskStatus:
+        proto_status = a2a_pb2.TaskStatus(
+            state=cls.task_state(status.state),
+            update=cls.message(status.message),
+        )
+        if status.timestamp:
+            proto_status.timestamp.FromJsonString(
+                str(status.timestamp).replace('+00:00', 'Z')
+            )
+        return proto_status
+
+    @classmethod
+    def task_state(cls, state: types.TaskState) -> a2a_pb2.TaskState:
+        match state:
+            case types.TaskState.submitted:
+                return a2a_pb2.TaskState.TASK_STATE_SUBMITTED
+            case types.TaskState.working:
+                return a2a_pb2.TaskState.TASK_STATE_WORKING
+            case types.TaskState.completed:
+                return a2a_pb2.TaskState.TASK_STATE_COMPLETED
+            case types.TaskState.canceled:
+                return a2a_pb2.TaskState.TASK_STATE_CANCELLED
+            case types.TaskState.failed:
+                return a2a_pb2.TaskState.TASK_STATE_FAILED
+            case types.TaskState.input_required:
+                return a2a_pb2.TaskState.TASK_STATE_INPUT_REQUIRED
+            case types.TaskState.auth_required:
+                return a2a_pb2.TaskState.TASK_STATE_AUTH_REQUIRED
+            case types.TaskState.rejected:
+                return a2a_pb2.TaskState.TASK_STATE_REJECTED
+            case _:
+                return a2a_pb2.TaskState.TASK_STATE_UNSPECIFIED
+
+    @classmethod
+    def artifact(cls, artifact: types.Artifact) -> a2a_pb2.Artifact:
+        return a2a_pb2.Artifact(
+            artifact_id=artifact.artifact_id,
+            description=artifact.description,
+            metadata=cls.metadata(artifact.metadata),
+            name=artifact.name,
+            parts=[cls.part(p) for p in artifact.parts],
+            extensions=artifact.extensions or [],
+        )
+
+    @classmethod
+    def authentication_info(
+        cls, info: types.PushNotificationAuthenticationInfo
+    ) -> a2a_pb2.AuthenticationInfo:
+        return a2a_pb2.AuthenticationInfo(
+            schemes=info.schemes,
+            credentials=info.credentials,
+        )
+
+    @classmethod
+    def push_notification_config(
+        cls, config: types.PushNotificationConfig
+    ) -> a2a_pb2.PushNotificationConfig:
+        auth_info = (
+            cls.authentication_info(config.authentication)
+            if config.authentication
+            else None
+        )
+        return a2a_pb2.PushNotificationConfig(
+            id=config.id or '',
+            url=config.url,
+            token=config.token,
+            authentication=auth_info,
+        )
+
+    @classmethod
+    def task_artifact_update_event(
+        cls, event: types.TaskArtifactUpdateEvent
+    ) -> a2a_pb2.TaskArtifactUpdateEvent:
+        return a2a_pb2.TaskArtifactUpdateEvent(
+            task_id=event.task_id,
+            context_id=event.context_id,
+            artifact=cls.artifact(event.artifact),
+            metadata=cls.metadata(event.metadata),
+            append=event.append or False,
+            last_chunk=event.last_chunk or False,
+        )
+
+    @classmethod
+    def task_status_update_event(
+        cls, event: types.TaskStatusUpdateEvent
+    ) -> a2a_pb2.TaskStatusUpdateEvent:
+        return a2a_pb2.TaskStatusUpdateEvent(
+            task_id=event.task_id,
+            context_id=event.context_id,
+            status=cls.task_status(event.status),
+            metadata=cls.metadata(event.metadata),
+            final=event.final,
+        )
+
+    @classmethod
+    def message_send_configuration(
+        cls, config: types.MessageSendConfiguration | None
+    ) -> a2a_pb2.SendMessageConfiguration | None:
+        # An empty configuration reads as blocking=false, so send none and
+        # leave the server on its blocking default.
+        if not config:
+            return None
+        return a2a_pb2.SendMessageConfiguration(
+            accepted_output_modes=config.accepted_output_modes,
+            push_notification=cls.push_notification_config(
+                config.push_notification_config
+            )
+            if config.push_notification_config
+            else None,
+            history_length=config.history_length,
+            blocking=config.blocking or False,
+        )
+
+    @classmethod
+    def update_event(
+        cls,
+        event: types.Task
+        | types.Message
+        | types.TaskStatusUpdateEvent
+        | types.TaskArtifactUpdateEvent,
+    ) -> a2a_pb2.StreamResponse:
+        """Converts a task, message, or task update event to a StreamResponse."""
+        return cls.stream_response(event)
+
+    @classmethod
+    def task_or_message(
+        cls, event: types.Task | types.Message
+    ) -> a2a_pb2.SendMessageResponse:
+        if isinstance(event, types.Message):
+            return a2a_pb2.SendMessageResponse(
+                msg=cls.message(event),
+            )
+        return a2a_pb2.SendMessageResponse(
+            task=cls.task(event),
+        )
+
+    @classmethod
+    def stream_response(
+        cls,
+        event: (
+            types.Message
+            | types.Task
+            | types.TaskStatusUpdateEvent
+            | types.TaskArtifactUpdateEvent
+        ),
+    ) -> a2a_pb2.StreamResponse:
+        if isinstance(event, types.Message):
+            return a2a_pb2.StreamResponse(msg=cls.message(event))
+        if isinstance(event, types.Task):
+            return a2a_pb2.StreamResponse(task=cls.task(event))
+        if isinstance(event, types.TaskStatusUpdateEvent):
+            return a2a_pb2.StreamResponse(
+                status_update=cls.task_status_update_event(event),
+            )
+        if isinstance(event, types.TaskArtifactUpdateEvent):
+            return a2a_pb2.StreamResponse(
+                artifact_update=cls.task_artifact_update_event(event),
+            )
+        raise ValueError(f'Unsupported event type: {type(event)}')
+
+    @classmethod
+    def task_push_notification_config(
+        cls, config: types.TaskPushNotificationConfig
+    ) -> a2a_pb2.TaskPushNotificationConfig:
+        return a2a_pb2.TaskPushNotificationConfig(
+            name=f'tasks/{config.task_id}/pushNotificationConfigs/{config.push_notification_config.id}',
+            push_notification_config=cls.push_notification_config(
+                config.push_notification_config,
+            ),
+        )
+
+    @classmethod
+    def agent_card(
+        cls,
+        card: types.AgentCard,
+    ) -> a2a_pb2.AgentCard:
+        return a2a_pb2.AgentCard(
+            capabilities=cls.capabilities(card.capabilities),
+            default_input_modes=list(card.default_input_modes),
+            default_output_modes=list(card.default_output_modes),
+            description=card.description,
+            documentation_url=card.documentation_url,
+            name=card.name,
+            provider=cls.provider(card.provider),
+            security=cls.security(card.security),
+            security_schemes=cls.security_schemes(card.security_schemes),
+            skills=[cls.skill(x) for x in card.skills] if card.skills else [],
+            url=card.url,
+            version=card.version,
+            supports_authenticated_extended_card=bool(
+                card.supports_authenticated_extended_card
+            ),
+            preferred_transport=card.preferred_transport,
+            protocol_version=card.protocol_version,
+            additional_interfaces=[
+                cls.agent_interface(x) for x in card.additional_interfaces
+            ]
+            if card.additional_interfaces
+            else None,
+            signatures=[cls.agent_card_signature(x) for x in card.signatures]
+            if card.signatures
+            else None,
+            icon_url=card.icon_url,
+        )
+
+    @classmethod
+    def agent_card_signature(
+        cls, signature: types.AgentCardSignature
+    ) -> a2a_pb2.AgentCardSignature:
+        return a2a_pb2.AgentCardSignature(
+            protected=signature.protected,
+            signature=signature.signature,
+            header=dict_to_struct(signature.header)
+            if signature.header is not None
+            else None,
+        )
+
+    @classmethod
+    def agent_interface(
+        cls,
+        interface: types.AgentInterface,
+    ) -> a2a_pb2.AgentInterface:
+        return a2a_pb2.AgentInterface(
+            transport=interface.transport,
+            url=interface.url,
+        )
+
+    @classmethod
+    def capabilities(
+        cls, capabilities: types.AgentCapabilities
+    ) -> a2a_pb2.AgentCapabilities:
+        return a2a_pb2.AgentCapabilities(
+            streaming=bool(capabilities.streaming),
+            push_notifications=bool(capabilities.push_notifications),
+            extensions=[
+                cls.extension(x) for x in capabilities.extensions or []
+            ],
+        )
+
+    @classmethod
+    def extension(
+        cls,
+        extension: types.AgentExtension,
+    ) -> a2a_pb2.AgentExtension:
+        return a2a_pb2.AgentExtension(
+            uri=extension.uri,
+            description=extension.description,
+            params=dict_to_struct(extension.params)
+            if extension.params
+            else None,
+            required=extension.required,
+        )
+
+    @classmethod
+    def provider(
+        cls, provider: types.AgentProvider | None
+    ) -> a2a_pb2.AgentProvider | None:
+        if not provider:
+            return None
+        return a2a_pb2.AgentProvider(
+            organization=provider.organization,
+            url=provider.url,
+        )
+
+    @classmethod
+    def security(
+        cls,
+        security: list[dict[str, list[str]]] | None,
+    ) -> list[a2a_pb2.Security] | None:
+        if not security:
+            return None
+        return [
+            a2a_pb2.Security(
+                schemes={k: a2a_pb2.StringList(list=v) for (k, v) in s.items()}
+            )
+            for s in security
+        ]
+
+    @classmethod
+    def security_schemes(
+        cls,
+        schemes: dict[str, types.SecurityScheme] | None,
+    ) -> dict[str, a2a_pb2.SecurityScheme] | None:
+        if not schemes:
+            return None
+        return {k: cls.security_scheme(v) for (k, v) in schemes.items()}
+
+    @classmethod
+    def security_scheme(
+        cls,
+        scheme: types.SecurityScheme,
+    ) -> a2a_pb2.SecurityScheme:
+        if isinstance(scheme.root, types.APIKeySecurityScheme):
+            return a2a_pb2.SecurityScheme(
+                api_key_security_scheme=a2a_pb2.APIKeySecurityScheme(
+                    description=scheme.root.description,
+                    location=scheme.root.in_.value,
+                    name=scheme.root.name,
+                )
+            )
+        if isinstance(scheme.root, types.HTTPAuthSecurityScheme):
+            return a2a_pb2.SecurityScheme(
+                http_auth_security_scheme=a2a_pb2.HTTPAuthSecurityScheme(
+                    description=scheme.root.description,
+                    scheme=scheme.root.scheme,
+                    bearer_format=scheme.root.bearer_format,
+                )
+            )
+        if isinstance(scheme.root, types.OAuth2SecurityScheme):
+            return a2a_pb2.SecurityScheme(
+                oauth2_security_scheme=a2a_pb2.OAuth2SecurityScheme(
+                    description=scheme.root.description,
+                    flows=cls.oauth2_flows(scheme.root.flows),
+                    oauth2_metadata_url=scheme.root.oauth2_metadata_url,
+                )
+            )
+        if isinstance(scheme.root, types.MutualTLSSecurityScheme):
+            return a2a_pb2.SecurityScheme(
+                mtls_security_scheme=a2a_pb2.MutualTlsSecurityScheme(
+                    description=scheme.root.description,
+                )
+            )
+        return a2a_pb2.SecurityScheme(
+            open_id_connect_security_scheme=a2a_pb2.OpenIdConnectSecurityScheme(
+                description=scheme.root.description,
+                open_id_connect_url=scheme.root.open_id_connect_url,
+            )
+        )
+
+    @classmethod
+    def oauth2_flows(cls, flows: types.OAuthFlows) -> a2a_pb2.OAuthFlows:
+        if flows.authorization_code:
+            return a2a_pb2.OAuthFlows(
+                authorization_code=a2a_pb2.AuthorizationCodeOAuthFlow(
+                    authorization_url=flows.authorization_code.authorization_url,
+                    refresh_url=flows.authorization_code.refresh_url,
+                    scopes=dict(flows.authorization_code.scopes.items()),
+                    token_url=flows.authorization_code.token_url,
+                ),
+            )
+        if flows.client_credentials:
+            return a2a_pb2.OAuthFlows(
+                client_credentials=a2a_pb2.ClientCredentialsOAuthFlow(
+                    refresh_url=flows.client_credentials.refresh_url,
+                    scopes=dict(flows.client_credentials.scopes.items()),
+                    token_url=flows.client_credentials.token_url,
+                ),
+            )
+        if flows.implicit:
+            return a2a_pb2.OAuthFlows(
+                implicit=a2a_pb2.ImplicitOAuthFlow(
+                    authorization_url=flows.implicit.authorization_url,
+                    refresh_url=flows.implicit.refresh_url,
+                    scopes=dict(flows.implicit.scopes.items()),
+                ),
+            )
+        if flows.password:
+            return a2a_pb2.OAuthFlows(
+                password=a2a_pb2.PasswordOAuthFlow(
+                    refresh_url=flows.password.refresh_url,
+                    scopes=dict(flows.password.scopes.items()),
+                    token_url=flows.password.token_url,
+                ),
+            )
+        # No v0.3 flow is set, e.g. for a v1.0 device code flow, which v0.3
+        # does not have.
+        return a2a_pb2.OAuthFlows()
+
+    @classmethod
+    def skill(cls, skill: types.AgentSkill) -> a2a_pb2.AgentSkill:
+        return a2a_pb2.AgentSkill(
+            id=skill.id,
+            name=skill.name,
+            description=skill.description,
+            tags=skill.tags,
+            examples=skill.examples,
+            input_modes=skill.input_modes,
+            output_modes=skill.output_modes,
+            security=cls.security(skill.security),
+        )
+
+    @classmethod
+    def role(cls, role: types.Role) -> a2a_pb2.Role:
+        match role:
+            case types.Role.user:
+                return a2a_pb2.Role.ROLE_USER
+            case types.Role.agent:
+                return a2a_pb2.Role.ROLE_AGENT
+            case _:
+                return a2a_pb2.Role.ROLE_UNSPECIFIED
+
+
+class FromProto:
+    """Converts proto types to Python types."""
+
+    @classmethod
+    def message(cls, message: a2a_pb2.Message) -> types.Message:
+        return types.Message(
+            message_id=message.message_id,
+            parts=[cls.part(p) for p in message.content],
+            context_id=message.context_id or None,
+            task_id=message.task_id or None,
+            role=cls.role(message.role),
+            metadata=cls.metadata(message.metadata),
+            extensions=list(message.extensions) or None,
+        )
+
+    @classmethod
+    def metadata(cls, metadata: struct_pb2.Struct) -> dict[str, Any]:
+        if not metadata.fields:
+            return {}
+        return json_format.MessageToDict(metadata)
+
+    @classmethod
+    def part(cls, part: a2a_pb2.Part) -> types.Part:
+        if part.HasField('text'):
+            return types.Part(
+                root=types.TextPart(
+                    text=part.text,
+                    metadata=cls.metadata(part.metadata)
+                    if part.metadata
+                    else None,
+                ),
+            )
+        if part.HasField('file'):
+            return types.Part(
+                root=types.FilePart(
+                    file=cls.file(part.file),
+                    metadata=cls.metadata(part.metadata)
+                    if part.metadata
+                    else None,
+                ),
+            )
+        if part.HasField('data'):
+            return types.Part(
+                root=types.DataPart(
+                    data=cls.data(part.data),
+                    metadata=cls.metadata(part.metadata)
+                    if part.metadata
+                    else None,
+                ),
+            )
+        raise ValueError(f'Unsupported part type: {part}')
+
+    @classmethod
+    def data(cls, data: a2a_pb2.DataPart) -> dict[str, Any]:
+        json_data = json_format.MessageToJson(data.data)
+        return json.loads(json_data)
+
+    @classmethod
+    def file(
+        cls, file: a2a_pb2.FilePart
+    ) -> types.FileWithUri | types.FileWithBytes:
+        common_args = {
+            'mime_type': file.mime_type or None,
+            'name': file.name or None,
+        }
+        if file.HasField('file_with_uri'):
+            return types.FileWithUri(
+                uri=file.file_with_uri,
+                **common_args,
+            )
+        return types.FileWithBytes(
+            bytes=file.file_with_bytes.decode('utf-8'),
+            **common_args,
+        )
+
+    @classmethod
+    def task_or_message(
+        cls, event: a2a_pb2.SendMessageResponse
+    ) -> types.Task | types.Message:
+        if event.HasField('msg'):
+            return cls.message(event.msg)
+        return cls.task(event.task)
+
+    @classmethod
+    def task(cls, task: a2a_pb2.Task) -> types.Task:
+        return types.Task(
+            id=task.id,
+            context_id=task.context_id,
+            status=cls.task_status(task.status),
+            artifacts=[cls.artifact(a) for a in task.artifacts],
+            history=[cls.message(h) for h in task.history],
+            metadata=cls.metadata(task.metadata),
+        )
+
+    @classmethod
+    def task_status(cls, status: a2a_pb2.TaskStatus) -> types.TaskStatus:
+        return types.TaskStatus(
+            state=cls.task_state(status.state),
+            message=cls.message(status.update)
+            if status.HasField('update')
+            else None,
+            timestamp=status.timestamp.ToJsonString()
+            if status.HasField('timestamp')
+            else None,
+        )
+
+    @classmethod
+    def task_state(cls, state: a2a_pb2.TaskState) -> types.TaskState:
+        match state:
+            case a2a_pb2.TaskState.TASK_STATE_SUBMITTED:
+                return types.TaskState.submitted
+            case a2a_pb2.TaskState.TASK_STATE_WORKING:
+                return types.TaskState.working
+            case a2a_pb2.TaskState.TASK_STATE_COMPLETED:
+                return types.TaskState.completed
+            case a2a_pb2.TaskState.TASK_STATE_CANCELLED:
+                return types.TaskState.canceled
+            case a2a_pb2.TaskState.TASK_STATE_FAILED:
+                return types.TaskState.failed
+            case a2a_pb2.TaskState.TASK_STATE_INPUT_REQUIRED:
+                return types.TaskState.input_required
+            case a2a_pb2.TaskState.TASK_STATE_AUTH_REQUIRED:
+                return types.TaskState.auth_required
+            case a2a_pb2.TaskState.TASK_STATE_REJECTED:
+                return types.TaskState.rejected
+            case _:
+                return types.TaskState.unknown
+
+    @classmethod
+    def artifact(cls, artifact: a2a_pb2.Artifact) -> types.Artifact:
+        return types.Artifact(
+            artifact_id=artifact.artifact_id,
+            description=artifact.description,
+            metadata=cls.metadata(artifact.metadata),
+            name=artifact.name,
+            parts=[cls.part(p) for p in artifact.parts],
+            extensions=artifact.extensions or None,
+        )
+
+    @classmethod
+    def task_artifact_update_event(
+        cls, event: a2a_pb2.TaskArtifactUpdateEvent
+    ) -> types.TaskArtifactUpdateEvent:
+        return types.TaskArtifactUpdateEvent(
+            task_id=event.task_id,
+            context_id=event.context_id,
+            artifact=cls.artifact(event.artifact),
+            metadata=cls.metadata(event.metadata),
+            append=event.append,
+            last_chunk=event.last_chunk,
+        )
+
+    @classmethod
+    def task_status_update_event(
+        cls, event: a2a_pb2.TaskStatusUpdateEvent
+    ) -> types.TaskStatusUpdateEvent:
+        return types.TaskStatusUpdateEvent(
+            task_id=event.task_id,
+            context_id=event.context_id,
+            status=cls.task_status(event.status),
+            metadata=cls.metadata(event.metadata),
+            final=event.final,
+        )
+
+    @classmethod
+    def push_notification_config(
+        cls, config: a2a_pb2.PushNotificationConfig
+    ) -> types.PushNotificationConfig:
+        return types.PushNotificationConfig(
+            id=config.id,
+            url=config.url,
+            token=config.token,
+            authentication=cls.authentication_info(config.authentication)
+            if config.HasField('authentication')
+            else None,
+        )
+
+    @classmethod
+    def authentication_info(
+        cls, info: a2a_pb2.AuthenticationInfo
+    ) -> types.PushNotificationAuthenticationInfo:
+        return types.PushNotificationAuthenticationInfo(
+            schemes=list(info.schemes),
+            credentials=info.credentials,
+        )
+
+    @classmethod
+    def message_send_configuration(
+        cls, config: a2a_pb2.SendMessageConfiguration
+    ) -> types.MessageSendConfiguration:
+        return types.MessageSendConfiguration(
+            accepted_output_modes=list(config.accepted_output_modes),
+            push_notification_config=cls.push_notification_config(
+                config.push_notification
+            )
+            if config.HasField('push_notification')
+            else None,
+            history_length=config.history_length
+            if config.history_length
+            else None,
+            blocking=config.blocking,
+        )
+
+    @classmethod
+    def message_send_params(
+        cls, request: a2a_pb2.SendMessageRequest
+    ) -> types.MessageSendParams:
+        return types.MessageSendParams(
+            configuration=cls.message_send_configuration(request.configuration)
+            if request.HasField('configuration')
+            else None,
+            message=cls.message(request.request),
+            metadata=cls.metadata(request.metadata),
+        )
+
+    @classmethod
+    def task_id_params(
+        cls,
+        request: (
+            a2a_pb2.CancelTaskRequest
+            | a2a_pb2.TaskSubscriptionRequest
+            | a2a_pb2.GetTaskPushNotificationConfigRequest
+        ),
+    ) -> types.TaskIdParams:
+        if isinstance(request, a2a_pb2.GetTaskPushNotificationConfigRequest):
+            m = TASK_PUSH_CONFIG_NAME_MATCH.match(request.name)
+            if not m:
+                raise InvalidParamsError(message=f'No task for {request.name}')
+            return types.TaskIdParams(id=m.group(1))
+        m = TASK_NAME_MATCH.match(request.name)
+        if not m:
+            raise InvalidParamsError(message=f'No task for {request.name}')
+        return types.TaskIdParams(id=m.group(1))
+
+    @classmethod
+    def task_push_notification_config_request(
+        cls,
+        request: a2a_pb2.CreateTaskPushNotificationConfigRequest,
+    ) -> types.TaskPushNotificationConfig:
+        m = TASK_NAME_MATCH.match(request.parent)
+        if not m:
+            raise InvalidParamsError(message=f'No task for {request.parent}')
+        return types.TaskPushNotificationConfig(
+            push_notification_config=cls.push_notification_config(
+                request.config.push_notification_config,
+            ),
+            task_id=m.group(1),
+        )
+
+    @classmethod
+    def task_push_notification_config(
+        cls,
+        config: a2a_pb2.TaskPushNotificationConfig,
+    ) -> types.TaskPushNotificationConfig:
+        m = TASK_PUSH_CONFIG_NAME_MATCH.match(config.name)
+        if not m:
+            raise InvalidParamsError(
+                message=f'Bad TaskPushNotificationConfig resource name {config.name}'
+            )
+        return types.TaskPushNotificationConfig(
+            push_notification_config=cls.push_notification_config(
+                config.push_notification_config,
+            ),
+            task_id=m.group(1),
+        )
+
+    @classmethod
+    def agent_card(
+        cls,
+        card: a2a_pb2.AgentCard,
+    ) -> types.AgentCard:
+        return types.AgentCard(
+            capabilities=cls.capabilities(card.capabilities),
+            default_input_modes=list(card.default_input_modes),
+            default_output_modes=list(card.default_output_modes),
+            description=card.description,
+            documentation_url=card.documentation_url,
+            name=card.name,
+            provider=cls.provider(card.provider)
+            if card.HasField('provider')
+            else None,
+            security=cls.security(list(card.security)),
+            security_schemes=cls.security_schemes(dict(card.security_schemes)),
+            skills=[cls.skill(x) for x in card.skills] if card.skills else [],
+            url=card.url,
+            version=card.version,
+            supports_authenticated_extended_card=card.supports_authenticated_extended_card,
+            preferred_transport=card.preferred_transport,
+            protocol_version=card.protocol_version,
+            additional_interfaces=[
+                cls.agent_interface(x) for x in card.additional_interfaces
+            ]
+            if card.additional_interfaces
+            else None,
+            signatures=[cls.agent_card_signature(x) for x in card.signatures]
+            if card.signatures
+            else None,
+            icon_url=card.icon_url or None,
+        )
+
+    @classmethod
+    def agent_card_signature(
+        cls, signature: a2a_pb2.AgentCardSignature
+    ) -> types.AgentCardSignature:
+        return types.AgentCardSignature(
+            protected=signature.protected,
+            signature=signature.signature,
+            header=json_format.MessageToDict(signature.header),
+        )
+
+    @classmethod
+    def agent_interface(
+        cls,
+        interface: a2a_pb2.AgentInterface,
+    ) -> types.AgentInterface:
+        return types.AgentInterface(
+            transport=interface.transport,
+            url=interface.url,
+        )
+
+    @classmethod
+    def task_query_params(
+        cls,
+        request: a2a_pb2.GetTaskRequest,
+    ) -> types.TaskQueryParams:
+        m = TASK_NAME_MATCH.match(request.name)
+        if not m:
+            raise InvalidParamsError(message=f'No task for {request.name}')
+        return types.TaskQueryParams(
+            history_length=request.history_length
+            if request.history_length
+            else None,
+            id=m.group(1),
+            metadata=None,
+        )
+
+    @classmethod
+    def capabilities(
+        cls, capabilities: a2a_pb2.AgentCapabilities
+    ) -> types.AgentCapabilities:
+        return types.AgentCapabilities(
+            streaming=capabilities.streaming,
+            push_notifications=capabilities.push_notifications,
+            extensions=[
+                cls.agent_extension(x) for x in capabilities.extensions
+            ],
+        )
+
+    @classmethod
+    def agent_extension(
+        cls,
+        extension: a2a_pb2.AgentExtension,
+    ) -> types.AgentExtension:
+        return types.AgentExtension(
+            uri=extension.uri,
+            description=extension.description,
+            params=json_format.MessageToDict(extension.params),
+            required=extension.required,
+        )
+
+    @classmethod
+    def security(
+        cls,
+        security: list[a2a_pb2.Security] | None,
+    ) -> list[dict[str, list[str]]] | None:
+        if not security:
+            return None
+        return [
+            {k: list(v.list) for (k, v) in s.schemes.items()} for s in security
+        ]
+
+    @classmethod
+    def provider(
+        cls, provider: a2a_pb2.AgentProvider | None
+    ) -> types.AgentProvider | None:
+        if not provider:
+            return None
+        return types.AgentProvider(
+            organization=provider.organization,
+            url=provider.url,
+        )
+
+    @classmethod
+    def security_schemes(
+        cls, schemes: dict[str, a2a_pb2.SecurityScheme]
+    ) -> dict[str, types.SecurityScheme]:
+        return {k: cls.security_scheme(v) for (k, v) in schemes.items()}
+
+    @classmethod
+    def security_scheme(
+        cls,
+        scheme: a2a_pb2.SecurityScheme,
+    ) -> types.SecurityScheme:
+        if scheme.HasField('api_key_security_scheme'):
+            return types.SecurityScheme(
+                root=types.APIKeySecurityScheme(
+                    description=scheme.api_key_security_scheme.description,
+                    name=scheme.api_key_security_scheme.name,
+                    in_=types.In(scheme.api_key_security_scheme.location),  # type: ignore[call-arg]
+                )
+            )
+        if scheme.HasField('http_auth_security_scheme'):
+            return types.SecurityScheme(
+                root=types.HTTPAuthSecurityScheme(
+                    description=scheme.http_auth_security_scheme.description,
+                    scheme=scheme.http_auth_security_scheme.scheme,
+                    bearer_format=scheme.http_auth_security_scheme.bearer_format,
+                )
+            )
+        if scheme.HasField('oauth2_security_scheme'):
+            return types.SecurityScheme(
+                root=types.OAuth2SecurityScheme(
+                    description=scheme.oauth2_security_scheme.description,
+                    flows=cls.oauth2_flows(scheme.oauth2_security_scheme.flows),
+                    oauth2_metadata_url=scheme.oauth2_security_scheme.oauth2_metadata_url
+                    or None,
+                )
+            )
+        if scheme.HasField('mtls_security_scheme'):
+            return types.SecurityScheme(
+                root=types.MutualTLSSecurityScheme(
+                    description=scheme.mtls_security_scheme.description,
+                )
+            )
+        return types.SecurityScheme(
+            root=types.OpenIdConnectSecurityScheme(
+                description=scheme.open_id_connect_security_scheme.description,
+                open_id_connect_url=scheme.open_id_connect_security_scheme.open_id_connect_url,
+            )
+        )
+
+    @classmethod
+    def oauth2_flows(cls, flows: a2a_pb2.OAuthFlows) -> types.OAuthFlows:
+        if flows.HasField('authorization_code'):
+            return types.OAuthFlows(
+                authorization_code=types.AuthorizationCodeOAuthFlow(
+                    authorization_url=flows.authorization_code.authorization_url,
+                    refresh_url=flows.authorization_code.refresh_url,
+                    scopes=dict(flows.authorization_code.scopes.items()),
+                    token_url=flows.authorization_code.token_url,
+                ),
+            )
+        if flows.HasField('client_credentials'):
+            return types.OAuthFlows(
+                client_credentials=types.ClientCredentialsOAuthFlow(
+                    refresh_url=flows.client_credentials.refresh_url,
+                    scopes=dict(flows.client_credentials.scopes.items()),
+                    token_url=flows.client_credentials.token_url,
+                ),
+            )
+        if flows.HasField('implicit'):
+            return types.OAuthFlows(
+                implicit=types.ImplicitOAuthFlow(
+                    authorization_url=flows.implicit.authorization_url,
+                    refresh_url=flows.implicit.refresh_url,
+                    scopes=dict(flows.implicit.scopes.items()),
+                ),
+            )
+        if flows.HasField('password'):
+            return types.OAuthFlows(
+                password=types.PasswordOAuthFlow(
+                    refresh_url=flows.password.refresh_url,
+                    scopes=dict(flows.password.scopes.items()),
+                    token_url=flows.password.token_url,
+                ),
+            )
+        return types.OAuthFlows()
+
+    @classmethod
+    def stream_response(
+        cls,
+        response: a2a_pb2.StreamResponse,
+    ) -> (
+        types.Message
+        | types.Task
+        | types.TaskStatusUpdateEvent
+        | types.TaskArtifactUpdateEvent
+    ):
+        if response.HasField('msg'):
+            return cls.message(response.msg)
+        if response.HasField('task'):
+            return cls.task(response.task)
+        if response.HasField('status_update'):
+            return cls.task_status_update_event(response.status_update)
+        if response.HasField('artifact_update'):
+            return cls.task_artifact_update_event(response.artifact_update)
+        raise ValueError('Unsupported StreamResponse type')
+
+    @classmethod
+    def list_task_push_notification_config_response(
+        cls, response: a2a_pb2.ListTaskPushNotificationConfigResponse
+    ) -> types.ListTaskPushNotificationConfigResponse:
+        return types.ListTaskPushNotificationConfigResponse(
+            root=types.ListTaskPushNotificationConfigSuccessResponse(
+                result=[
+                    cls.task_push_notification_config(c)
+                    for c in response.configs
+                ],
+                id=None,
+            )
+        )
+
+    @classmethod
+    def skill(cls, skill: a2a_pb2.AgentSkill) -> types.AgentSkill:
+        return types.AgentSkill(
+            id=skill.id,
+            name=skill.name,
+            description=skill.description,
+            tags=list(skill.tags),
+            examples=list(skill.examples),
+            input_modes=list(skill.input_modes),
+            output_modes=list(skill.output_modes),
+            security=cls.security(list(skill.security)),
+        )
+
+    @classmethod
+    def role(cls, role: a2a_pb2.Role) -> types.Role:
+        match role:
+            case a2a_pb2.Role.ROLE_USER:
+                return types.Role.user
+            case a2a_pb2.Role.ROLE_AGENT:
+                return types.Role.agent
+            case _:
+                return types.Role.agent
diff --git a/src/a2a/compat/v0_3/request_handler.py b/src/a2a/compat/v0_3/request_handler.py
new file mode 100644
index 000000000..9a530815d
--- /dev/null
+++ b/src/a2a/compat/v0_3/request_handler.py
@@ -0,0 +1,196 @@
+import logging
+
+from collections.abc import AsyncIterable
+
+from a2a.compat.v0_3 import conversions
+from a2a.compat.v0_3 import types as types_v03
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.types.a2a_pb2 import ListTaskPushNotificationConfigsRequest, Task
+from a2a.utils import proto_utils as core_proto_utils
+from a2a.utils.errors import TaskNotFoundError
+
+
+logger = logging.getLogger(__name__)
+
+
+class RequestHandler03:
+    """A protocol-agnostic v0.3 RequestHandler that delegates to the v1.0 RequestHandler."""
+
+    def __init__(self, request_handler: RequestHandler):
+        self.request_handler = request_handler
+
+    async def on_message_send(
+        self,
+        request: types_v03.SendMessageRequest,
+        context: ServerCallContext,
+    ) -> types_v03.Task | types_v03.Message:
+        """Sends a message using v0.3 protocol types."""
+        v10_req = conversions.to_core_send_message_request(request)
+        task_or_message = await self.request_handler.on_message_send(
+            v10_req, context
+        )
+        if isinstance(task_or_message, Task):
+            return conversions.to_compat_task(task_or_message)
+        return conversions.to_compat_message(task_or_message)
+
+    async def on_message_send_stream(
+        self,
+        request: types_v03.SendMessageRequest,
+        context: ServerCallContext,
+    ) -> AsyncIterable[types_v03.SendStreamingMessageSuccessResponse]:
+        """Sends a message stream using v0.3 protocol types."""
+        v10_req = conversions.to_core_send_message_request(request)
+        async for event in self.request_handler.on_message_send_stream(
+            v10_req, context
+        ):
+            v10_stream_resp = core_proto_utils.to_stream_response(event)
+            yield conversions.to_compat_stream_response(
+                v10_stream_resp, request.id
+            )
+
+    async def on_cancel_task(
+        self,
+        request: types_v03.CancelTaskRequest,
+        context: ServerCallContext,
+    ) -> types_v03.Task:
+        """Cancels a task using v0.3 protocol types."""
+        v10_req = conversions.to_core_cancel_task_request(request)
+        v10_task = await self.request_handler.on_cancel_task(v10_req, context)
+        if v10_task:
+            return conversions.to_compat_task(v10_task)
+        raise TaskNotFoundError
+
+    async def on_subscribe_to_task(
+        self,
+        request: types_v03.TaskResubscriptionRequest,
+        context: ServerCallContext,
+    ) -> AsyncIterable[types_v03.SendStreamingMessageSuccessResponse]:
+        """Subscribes to a task using v0.3 protocol types."""
+        v10_req = conversions.to_core_subscribe_to_task_request(request)
+        async for event in self.request_handler.on_subscribe_to_task(
+            v10_req, context
+        ):
+            v10_stream_resp = core_proto_utils.to_stream_response(event)
+            yield conversions.to_compat_stream_response(
+                v10_stream_resp, request.id
+            )
+
+    async def on_get_task_push_notification_config(
+        self,
+        request: types_v03.GetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> types_v03.TaskPushNotificationConfig:
+        """Gets a push notification config using v0.3 protocol types."""
+        v10_req = conversions.to_core_get_task_push_notification_config_request(
+            request
+        )
+        # v0.3 allows a get by task id alone. Prefer the config stored under
+        # the task id, which is where a config created without an id goes.
+        # Otherwise take the first, like v0.3 did.
+        if not v10_req.id:
+            v10_resp = await self.request_handler.on_list_task_push_notification_configs(
+                ListTaskPushNotificationConfigsRequest(task_id=v10_req.task_id),
+                context,
+            )
+            configs = list(v10_resp.configs)
+            v10_config = next(
+                (c for c in configs if c.id == v10_req.task_id),
+                configs[0] if configs else None,
+            )
+            if v10_config is None:
+                raise TaskNotFoundError
+            return conversions.to_compat_task_push_notification_config(
+                v10_config
+            )
+        v10_config = (
+            await self.request_handler.on_get_task_push_notification_config(
+                v10_req, context
+            )
+        )
+        return conversions.to_compat_task_push_notification_config(v10_config)
+
+    async def on_create_task_push_notification_config(
+        self,
+        request: types_v03.SetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> types_v03.TaskPushNotificationConfig:
+        """Creates a push notification config using v0.3 protocol types."""
+        v10_req = (
+            conversions.to_core_create_task_push_notification_config_request(
+                request
+            )
+        )
+        v10_config = (
+            await self.request_handler.on_create_task_push_notification_config(
+                v10_req, context
+            )
+        )
+        return conversions.to_compat_task_push_notification_config(v10_config)
+
+    async def on_get_task(
+        self,
+        request: types_v03.GetTaskRequest,
+        context: ServerCallContext,
+    ) -> types_v03.Task:
+        """Gets a task using v0.3 protocol types."""
+        v10_req = conversions.to_core_get_task_request(request)
+        v10_task = await self.request_handler.on_get_task(v10_req, context)
+        if v10_task:
+            return conversions.to_compat_task(v10_task)
+        raise TaskNotFoundError
+
+    async def on_list_task_push_notification_configs(
+        self,
+        request: types_v03.ListTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> list[types_v03.TaskPushNotificationConfig]:
+        """Lists push notification configs using v0.3 protocol types."""
+        v10_req = (
+            conversions.to_core_list_task_push_notification_config_request(
+                request
+            )
+        )
+        v10_resp = (
+            await self.request_handler.on_list_task_push_notification_configs(
+                v10_req, context
+            )
+        )
+        v03_resp = (
+            conversions.to_compat_list_task_push_notification_config_response(
+                v10_resp, request.id
+            )
+        )
+        if isinstance(
+            v03_resp.root,
+            types_v03.ListTaskPushNotificationConfigSuccessResponse,
+        ):
+            return v03_resp.root.result
+        return []
+
+    async def on_delete_task_push_notification_config(
+        self,
+        request: types_v03.DeleteTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> None:
+        """Deletes a push notification config using v0.3 protocol types."""
+        v10_req = (
+            conversions.to_core_delete_task_push_notification_config_request(
+                request
+            )
+        )
+        await self.request_handler.on_delete_task_push_notification_config(
+            v10_req, context
+        )
+
+    async def on_get_extended_agent_card(
+        self,
+        request: types_v03.GetAuthenticatedExtendedCardRequest,
+        context: ServerCallContext,
+    ) -> types_v03.AgentCard:
+        """Gets the authenticated extended agent card using v0.3 protocol types."""
+        v10_req = conversions.to_core_get_extended_agent_card_request(request)
+        v10_card = await self.request_handler.on_get_extended_agent_card(
+            v10_req, context
+        )
+        return conversions.to_compat_agent_card(v10_card)
diff --git a/src/a2a/compat/v0_3/rest_adapter.py b/src/a2a/compat/v0_3/rest_adapter.py
new file mode 100644
index 000000000..ed21a9752
--- /dev/null
+++ b/src/a2a/compat/v0_3/rest_adapter.py
@@ -0,0 +1,178 @@
+import functools
+import logging
+
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from sse_starlette.sse import EventSourceResponse
+    from starlette.requests import Request
+    from starlette.responses import JSONResponse, Response
+
+    from a2a.server.context import ServerCallContext
+    from a2a.server.request_handlers.request_handler import RequestHandler
+
+    _package_starlette_installed = True
+else:
+    try:
+        from sse_starlette.sse import EventSourceResponse
+        from starlette.requests import Request
+        from starlette.responses import JSONResponse, Response
+
+        _package_starlette_installed = True
+    except ImportError:
+        EventSourceResponse = Any
+        Request = Any
+        JSONResponse = Any
+        Response = Any
+
+        _package_starlette_installed = False
+
+
+from a2a.compat.v0_3.context_builders import V03ServerCallContextBuilder
+from a2a.compat.v0_3.rest_handler import REST03Handler
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    ServerCallContextBuilder,
+    create_event_source_response,
+)
+from a2a.utils import json_utils
+from a2a.utils.error_handlers import (
+    rest_error_handler,
+    rest_stream_error_handler,
+)
+from a2a.utils.errors import (
+    InvalidRequestError,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class REST03Adapter:
+    """Adapter to make RequestHandler work with v0.3 RESTful API.
+
+    Defines v0.3 REST request processors and their routes, as well as managing response generation including Server-Sent Events (SSE).
+    """
+
+    def __init__(
+        self,
+        http_handler: 'RequestHandler',
+        context_builder: 'ServerCallContextBuilder | None' = None,
+        shutdown_grace_period: float = 0,
+    ) -> None:
+        self.handler = REST03Handler(request_handler=http_handler)
+        self._context_builder = V03ServerCallContextBuilder(
+            context_builder or DefaultServerCallContextBuilder()
+        )
+        self._shutdown_grace_period = shutdown_grace_period
+
+    @rest_error_handler
+    async def _handle_request(
+        self,
+        method: 'Callable[[Request, ServerCallContext], Awaitable[Any]]',
+        request: Request,
+    ) -> Response:
+        call_context = self._context_builder.build(request)
+        response = await method(request, call_context)
+        return JSONResponse(content=response)
+
+    @rest_stream_error_handler
+    async def _handle_streaming_request(
+        self,
+        method: 'Callable[[Request, ServerCallContext], AsyncIterable[Any]]',
+        request: Request,
+    ) -> EventSourceResponse:
+        try:
+            await request.body()
+        except (ValueError, RuntimeError, OSError) as e:
+            raise InvalidRequestError(
+                message=f'Failed to pre-consume request body: {e}'
+            ) from e
+
+        call_context = self._context_builder.build(request)
+
+        # Fetch the first item before starting the SSE response so that
+        # errors raised before any event (e.g. a malformed body) are mapped
+        # to an HTTP error by @rest_stream_error_handler instead of an empty
+        # 200 stream, matching the v1.0 REST dispatcher.
+        stream = aiter(method(request, call_context))
+        try:
+            first_item = await anext(stream)
+        except StopAsyncIteration:
+            return create_event_source_response(
+                iter([]),
+                shutdown_grace_period=self._shutdown_grace_period,
+            )
+
+        async def event_generator(
+            stream: AsyncIterable[Any],
+        ) -> AsyncIterator[str]:
+            yield json_utils.dumps(first_item)
+            async for item in stream:
+                yield json_utils.dumps(item)
+
+        return create_event_source_response(
+            event_generator(stream),
+            shutdown_grace_period=self._shutdown_grace_period,
+        )
+
+    def routes(self) -> dict[tuple[str, str], Callable[[Request], Any]]:
+        """Constructs a dictionary of API routes and their corresponding handlers."""
+        routes: dict[tuple[str, str], Callable[[Request], Any]] = {
+            ('/v1/message:send', 'POST'): functools.partial(
+                self._handle_request, self.handler.on_message_send
+            ),
+            ('/v1/message:stream', 'POST'): functools.partial(
+                self._handle_streaming_request,
+                self.handler.on_message_send_stream,
+            ),
+            ('/v1/tasks/{id}:cancel', 'POST'): functools.partial(
+                self._handle_request, self.handler.on_cancel_task
+            ),
+            ('/v1/tasks/{id}:subscribe', 'GET'): functools.partial(
+                self._handle_streaming_request,
+                self.handler.on_subscribe_to_task,
+            ),
+            ('/v1/tasks/{id}:subscribe', 'POST'): functools.partial(
+                self._handle_streaming_request,
+                self.handler.on_subscribe_to_task,
+            ),
+            ('/v1/tasks/{id}', 'GET'): functools.partial(
+                self._handle_request, self.handler.on_get_task
+            ),
+            (
+                '/v1/tasks/{id}/pushNotificationConfigs/{push_id}',
+                'GET',
+            ): functools.partial(
+                self._handle_request, self.handler.get_push_notification
+            ),
+            (
+                '/v1/tasks/{id}/pushNotificationConfigs/{push_id}',
+                'DELETE',
+            ): functools.partial(
+                self._handle_request, self.handler.delete_push_notification
+            ),
+            (
+                '/v1/tasks/{id}/pushNotificationConfigs',
+                'POST',
+            ): functools.partial(
+                self._handle_request, self.handler.set_push_notification
+            ),
+            (
+                '/v1/tasks/{id}/pushNotificationConfigs',
+                'GET',
+            ): functools.partial(
+                self._handle_request, self.handler.list_push_notifications
+            ),
+            # ListTasks is intentionally absent: not in the A2A v0.3 spec (see
+            # issue #1043). Sibling v0.3 transports (jsonrpc_transport,
+            # grpc_transport, rest_transport) also reject list_tasks with
+            # NotImplementedError — do not add a route here.
+            ('/v1/card', 'GET'): functools.partial(
+                self._handle_request, self.handler.on_get_extended_agent_card
+            ),
+        }
+
+        return routes
diff --git a/src/a2a/compat/v0_3/rest_handler.py b/src/a2a/compat/v0_3/rest_handler.py
new file mode 100644
index 000000000..cfb770681
--- /dev/null
+++ b/src/a2a/compat/v0_3/rest_handler.py
@@ -0,0 +1,343 @@
+import logging
+
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+from google.protobuf.json_format import MessageToDict
+
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+
+    from a2a.server.request_handlers.request_handler import RequestHandler
+
+    _package_starlette_installed = True
+else:
+    try:
+        from starlette.requests import Request
+
+        _package_starlette_installed = True
+    except ImportError:
+        Request = Any
+
+        _package_starlette_installed = False
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2 as pb2_v03
+from a2a.compat.v0_3 import proto_utils
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.request_handler import RequestHandler03
+from a2a.server.context import ServerCallContext
+from a2a.utils import constants
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.proto_utils import parse_lenient
+from a2a.utils.telemetry import SpanKind, trace_class
+from a2a.utils.version_validator import validate_version
+
+
+logger = logging.getLogger(__name__)
+
+
+@trace_class(kind=SpanKind.SERVER)
+class REST03Handler:
+    """Maps incoming REST-like (JSON+HTTP) requests to the appropriate request handler method and formats responses for v0.3 compatibility."""
+
+    def __init__(
+        self,
+        request_handler: 'RequestHandler',
+    ):
+        """Initializes the REST03Handler.
+
+        Args:
+          request_handler: The underlying `RequestHandler` instance to delegate requests to (v1.0).
+        """
+        self.handler03 = RequestHandler03(request_handler=request_handler)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_message_send(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'message/send' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            A `dict` containing the result (Task or Message) in v0.3 format.
+        """
+        body = await request.body()
+        v03_pb_msg = pb2_v03.SendMessageRequest()
+        parse_lenient(body, v03_pb_msg)
+        v03_params_msg = proto_utils.FromProto.message_send_params(v03_pb_msg)
+        rpc_req = types_v03.SendMessageRequest(id='', params=v03_params_msg)
+
+        v03_resp = await self.handler03.on_message_send(rpc_req, context)
+
+        pb2_v03_resp = proto_utils.ToProto.task_or_message(v03_resp)
+        return MessageToDict(pb2_v03_resp)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_message_send_stream(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Handles the 'message/stream' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Yields:
+            JSON serialized objects containing streaming events in v0.3 format.
+        """
+        body = await request.body()
+        v03_pb_msg = pb2_v03.SendMessageRequest()
+        parse_lenient(body, v03_pb_msg)
+        v03_params_msg = proto_utils.FromProto.message_send_params(v03_pb_msg)
+        rpc_req = types_v03.SendMessageRequest(id='', params=v03_params_msg)
+
+        async for v03_stream_resp in self.handler03.on_message_send_stream(
+            rpc_req, context
+        ):
+            v03_pb_resp = proto_utils.ToProto.stream_response(
+                v03_stream_resp.result
+            )
+            yield MessageToDict(v03_pb_resp)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_cancel_task(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'tasks/cancel' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            A `dict` containing the updated Task in v0.3 format.
+        """
+        task_id = request.path_params['id']
+        rpc_req = types_v03.CancelTaskRequest(
+            id='',
+            params=types_v03.TaskIdParams(id=task_id),
+        )
+
+        v03_resp = await self.handler03.on_cancel_task(rpc_req, context)
+        pb2_v03_task = proto_utils.ToProto.task(v03_resp)
+        return MessageToDict(pb2_v03_task)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_subscribe_to_task(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Handles the 'tasks/{id}:subscribe' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Yields:
+            JSON serialized objects containing streaming events in v0.3 format.
+        """
+        task_id = request.path_params['id']
+        rpc_req = types_v03.TaskResubscriptionRequest(
+            id='',
+            params=types_v03.TaskIdParams(id=task_id),
+        )
+
+        async for v03_stream_resp in self.handler03.on_subscribe_to_task(
+            rpc_req, context
+        ):
+            v03_pb_resp = proto_utils.ToProto.stream_response(
+                v03_stream_resp.result
+            )
+            yield MessageToDict(v03_pb_resp)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def get_push_notification(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'tasks/pushNotificationConfig/get' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            A `dict` containing the config in v0.3 format.
+        """
+        task_id = request.path_params['id']
+        push_id = request.path_params['push_id']
+
+        rpc_req = types_v03.GetTaskPushNotificationConfigRequest(
+            id='',
+            params=types_v03.GetTaskPushNotificationConfigParams(
+                id=task_id, push_notification_config_id=push_id
+            ),
+        )
+
+        v03_resp = await self.handler03.on_get_task_push_notification_config(
+            rpc_req, context
+        )
+        pb2_v03_config = proto_utils.ToProto.task_push_notification_config(
+            v03_resp
+        )
+        return MessageToDict(pb2_v03_config)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def delete_push_notification(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'tasks/pushNotificationConfig/delete' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            An empty `dict`, the JSON form of `google.protobuf.Empty`.
+        """
+        task_id = request.path_params['id']
+        push_id = request.path_params['push_id']
+
+        rpc_req = types_v03.DeleteTaskPushNotificationConfigRequest(
+            id='',
+            params=types_v03.DeleteTaskPushNotificationConfigParams(
+                id=task_id, push_notification_config_id=push_id
+            ),
+        )
+
+        await self.handler03.on_delete_task_push_notification_config(
+            rpc_req, context
+        )
+        return {}
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def set_push_notification(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'tasks/pushNotificationConfig/set' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            A `dict` containing the config object in v0.3 format.
+        """
+        task_id = request.path_params['id']
+        body = await request.body()
+
+        v03_pb_push = pb2_v03.CreateTaskPushNotificationConfigRequest()
+        parse_lenient(body, v03_pb_push)
+
+        v03_params_push = (
+            proto_utils.FromProto.task_push_notification_config_request(
+                v03_pb_push
+            )
+        )
+        v03_params_push.task_id = task_id
+
+        rpc_req_push = types_v03.SetTaskPushNotificationConfigRequest(
+            id='',
+            params=v03_params_push,
+        )
+
+        v03_resp = await self.handler03.on_create_task_push_notification_config(
+            rpc_req_push, context
+        )
+        pb2_v03_config = proto_utils.ToProto.task_push_notification_config(
+            v03_resp
+        )
+        return MessageToDict(pb2_v03_config)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_get_task(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'v1/tasks/{id}' REST method.
+
+        Args:
+            request: The incoming `Request` object.
+            context: Context provided by the server.
+
+        Returns:
+            A `Task` object containing the Task in v0.3 format.
+        """
+        task_id = request.path_params['id']
+        history_length_str = request.query_params.get('historyLength')
+        try:
+            history_length = (
+                int(history_length_str) if history_length_str else None
+            )
+        except ValueError as e:
+            raise InvalidParamsError(
+                message=f'Failed to parse historyLength field: {e}.'
+            ) from e
+
+        rpc_req = types_v03.GetTaskRequest(
+            id='',
+            params=types_v03.TaskQueryParams(
+                id=task_id, history_length=history_length
+            ),
+        )
+
+        v03_resp = await self.handler03.on_get_task(rpc_req, context)
+        pb2_v03_task = proto_utils.ToProto.task(v03_resp)
+        return MessageToDict(pb2_v03_task)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def list_push_notifications(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'tasks/pushNotificationConfig/list' REST method."""
+        task_id = request.path_params['id']
+
+        rpc_req = types_v03.ListTaskPushNotificationConfigRequest(
+            id='',
+            params=types_v03.ListTaskPushNotificationConfigParams(id=task_id),
+        )
+
+        v03_resp = await self.handler03.on_list_task_push_notification_configs(
+            rpc_req, context
+        )
+
+        pb2_v03_resp = pb2_v03.ListTaskPushNotificationConfigResponse(
+            configs=[
+                proto_utils.ToProto.task_push_notification_config(c)
+                for c in v03_resp
+            ]
+        )
+
+        return MessageToDict(pb2_v03_resp)
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def on_get_extended_agent_card(
+        self,
+        request: Request,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        """Handles the 'v1/agent/authenticatedExtendedAgentCard' REST method."""
+        rpc_req = types_v03.GetAuthenticatedExtendedCardRequest(id=0)
+        v03_resp = await self.handler03.on_get_extended_agent_card(
+            rpc_req, context
+        )
+        return v03_resp.model_dump(mode='json', exclude_none=True)
diff --git a/src/a2a/compat/v0_3/rest_transport.py b/src/a2a/compat/v0_3/rest_transport.py
new file mode 100644
index 000000000..3f1e6b5c0
--- /dev/null
+++ b/src/a2a/compat/v0_3/rest_transport.py
@@ -0,0 +1,466 @@
+import contextlib
+import json
+import logging
+
+from collections.abc import AsyncGenerator
+from typing import Any, NoReturn
+from urllib.parse import quote
+
+import httpx
+
+from google.protobuf.json_format import MessageToDict, Parse, ParseDict
+
+from a2a.client.card_resolver import parse_agent_card
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.http_helpers import (
+    get_http_args,
+    send_http_request,
+    send_http_stream_request,
+)
+from a2a.compat.v0_3 import (
+    a2a_v0_3_pb2,
+    conversions,
+    proto_utils,
+)
+from a2a.compat.v0_3 import (
+    types as types_v03,
+)
+from a2a.compat.v0_3.extension_headers import add_legacy_extension_header
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.constants import PROTOCOL_VERSION_0_3, VERSION_HEADER
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP, MethodNotFoundError
+from a2a.utils.proto_utils import warn_on_missing_required_fields
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+_A2A_ERROR_NAME_TO_CLS = {
+    error_type.__name__: error_type for error_type in JSON_RPC_ERROR_CODE_MAP
+}
+
+
+def _quote_id(value: str) -> str:
+    """Percent-encodes an id so it stays a single URL path segment."""
+    return quote(value, safe='')
+
+
+@trace_class(kind=SpanKind.CLIENT)
+class CompatRestTransport(ClientTransport):
+    """A backward compatible REST transport for A2A v0.3."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        agent_card: AgentCard | None,
+        url: str,
+        subscribe_method_override: str | None = None,
+        *,
+        is_shared_httpx: bool = False,
+    ):
+        """Initializes the CompatRestTransport."""
+        self.url = url.removesuffix('/')
+        self.httpx_client = httpx_client
+        self.agent_card = agent_card
+        self.is_shared_httpx = is_shared_httpx
+        self._subscribe_method_override = subscribe_method_override
+        self._subscribe_auto_method_override = subscribe_method_override is None
+
+    async def send_message(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> SendMessageResponse:
+        """Sends a non-streaming message request to the agent."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+        req_proto = a2a_v0_3_pb2.SendMessageRequest(
+            request=proto_utils.ToProto.message(req_v03.params.message),
+            configuration=proto_utils.ToProto.message_send_configuration(
+                req_v03.params.configuration
+            ),
+            metadata=proto_utils.ToProto.metadata(req_v03.params.metadata),
+        )
+
+        response_data = await self._execute_request(
+            'POST',
+            '/v1/message:send',
+            context=context,
+            json=MessageToDict(req_proto),
+        )
+
+        resp_proto = ParseDict(
+            response_data,
+            a2a_v0_3_pb2.SendMessageResponse(),
+            ignore_unknown_fields=True,
+        )
+        which = resp_proto.WhichOneof('payload')
+        if which == 'task':
+            return SendMessageResponse(
+                task=conversions.to_core_task(
+                    proto_utils.FromProto.task(resp_proto.task)
+                )
+            )
+        if which == 'msg':
+            return SendMessageResponse(
+                message=conversions.to_core_message(
+                    proto_utils.FromProto.message(resp_proto.msg)
+                )
+            )
+        return SendMessageResponse()
+
+    async def send_message_streaming(
+        self,
+        request: SendMessageRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Sends a streaming message request to the agent and yields responses as they arrive."""
+        req_v03 = conversions.to_compat_send_message_request(
+            request, request_id=0
+        )
+        req_proto = a2a_v0_3_pb2.SendMessageRequest(
+            request=proto_utils.ToProto.message(req_v03.params.message),
+            configuration=proto_utils.ToProto.message_send_configuration(
+                req_v03.params.configuration
+            ),
+            metadata=proto_utils.ToProto.metadata(req_v03.params.metadata),
+        )
+
+        async for event in self._send_stream_request(
+            'POST',
+            '/v1/message:stream',
+            context=context,
+            json=MessageToDict(req_proto),
+        ):
+            yield event
+
+    async def get_task(
+        self,
+        request: GetTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Retrieves the current state and history of a specific task."""
+        params = {}
+        if request.HasField('history_length'):
+            params['historyLength'] = request.history_length
+
+        response_data = await self._execute_request(
+            'GET',
+            f'/v1/tasks/{_quote_id(request.id)}',
+            context=context,
+            params=params,
+        )
+        resp_proto = ParseDict(
+            response_data, a2a_v0_3_pb2.Task(), ignore_unknown_fields=True
+        )
+        return conversions.to_core_task(proto_utils.FromProto.task(resp_proto))
+
+    async def list_tasks(
+        self,
+        request: ListTasksRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTasksResponse:
+        """Retrieves tasks for an agent."""
+        raise NotImplementedError(
+            'ListTasks is not supported in A2A v0.3 REST.'
+        )
+
+    async def cancel_task(
+        self,
+        request: CancelTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> Task:
+        """Requests the agent to cancel a specific task."""
+        response_data = await self._execute_request(
+            'POST',
+            f'/v1/tasks/{_quote_id(request.id)}:cancel',
+            context=context,
+        )
+        resp_proto = ParseDict(
+            response_data, a2a_v0_3_pb2.Task(), ignore_unknown_fields=True
+        )
+        return conversions.to_core_task(proto_utils.FromProto.task(resp_proto))
+
+    async def create_task_push_notification_config(
+        self,
+        request: TaskPushNotificationConfig,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a specific task."""
+        req_v03 = (
+            conversions.to_compat_create_task_push_notification_config_request(
+                request, request_id=0
+            )
+        )
+        req_proto = a2a_v0_3_pb2.CreateTaskPushNotificationConfigRequest(
+            parent=f'tasks/{request.task_id}',
+            config_id=req_v03.params.push_notification_config.id,
+            config=proto_utils.ToProto.task_push_notification_config(
+                req_v03.params
+            ),
+        )
+        response_data = await self._execute_request(
+            'POST',
+            f'/v1/tasks/{_quote_id(request.task_id)}/pushNotificationConfigs',
+            context=context,
+            json=MessageToDict(req_proto),
+        )
+        resp_proto = ParseDict(
+            response_data,
+            a2a_v0_3_pb2.TaskPushNotificationConfig(),
+            ignore_unknown_fields=True,
+        )
+        return conversions.to_core_task_push_notification_config(
+            proto_utils.FromProto.task_push_notification_config(resp_proto)
+        )
+
+    async def get_task_push_notification_config(
+        self,
+        request: GetTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Retrieves the push notification configuration for a specific task."""
+        response_data = await self._execute_request(
+            'GET',
+            f'/v1/tasks/{_quote_id(request.task_id)}'
+            f'/pushNotificationConfigs/{_quote_id(request.id)}',
+            context=context,
+        )
+        resp_proto = ParseDict(
+            response_data,
+            a2a_v0_3_pb2.TaskPushNotificationConfig(),
+            ignore_unknown_fields=True,
+        )
+        return conversions.to_core_task_push_notification_config(
+            proto_utils.FromProto.task_push_notification_config(resp_proto)
+        )
+
+    async def list_task_push_notification_configs(
+        self,
+        request: ListTaskPushNotificationConfigsRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Lists push notification configurations for a specific task."""
+        response_data = await self._execute_request(
+            'GET',
+            f'/v1/tasks/{_quote_id(request.task_id)}/pushNotificationConfigs',
+            context=context,
+        )
+        resp_proto = ParseDict(
+            response_data,
+            a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse(),
+            ignore_unknown_fields=True,
+        )
+        return conversions.to_core_list_task_push_notification_config_response(
+            proto_utils.FromProto.list_task_push_notification_config_response(
+                resp_proto
+            )
+        )
+
+    async def delete_task_push_notification_config(
+        self,
+        request: DeleteTaskPushNotificationConfigRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a specific task."""
+        await self._execute_request(
+            'DELETE',
+            f'/v1/tasks/{request.task_id}/pushNotificationConfigs/{request.id}',
+            context=context,
+        )
+
+    async def subscribe(
+        self,
+        request: SubscribeToTaskRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        """Reconnects to get task updates.
+
+        This method implements backward compatibility logic for the subscribe
+        endpoint. It first attempts to use POST, which is the official method
+        for A2A subscribe endpoint. If the server returns 405 Method Not Allowed,
+        it falls back to GET and remembers this preference for future calls
+        on this transport instance. If both fail with 405, it will default back
+        to POST for next calls but will not retry again.
+        """
+        subscribe_method = self._subscribe_method_override or 'POST'
+        try:
+            async for event in self._send_stream_request(
+                subscribe_method,
+                f'/v1/tasks/{_quote_id(request.id)}:subscribe',
+                context=context,
+            ):
+                yield event
+        except A2AClientError as e:
+            # Check for 405 Method Not Allowed in the cause (httpx.HTTPStatusError)
+            cause = e.__cause__
+            if (
+                isinstance(cause, httpx.HTTPStatusError)
+                and cause.response.status_code == httpx.codes.METHOD_NOT_ALLOWED
+            ):
+                if self._subscribe_method_override:
+                    if self._subscribe_auto_method_override:
+                        self._subscribe_auto_method_override = False
+                        self._subscribe_method_override = 'POST'
+                    raise
+                else:
+                    self._subscribe_method_override = 'GET'
+                    async for event in self.subscribe(request, context=context):
+                        yield event
+            else:
+                raise
+
+    async def get_extended_agent_card(
+        self,
+        request: GetExtendedAgentCardRequest,
+        *,
+        context: ClientCallContext | None = None,
+    ) -> AgentCard:
+        """Retrieves the Extended AgentCard."""
+        card = self.agent_card
+        if card and not card.capabilities.extended_agent_card:
+            return card
+
+        response_data = await self._execute_request(
+            'GET', '/v1/card', context=context
+        )
+        # v0.3 servers send the card as JSON. parse_agent_card reads it like
+        # the card resolver does, and still accepts a card missing required
+        # fields, which only gets a warning.
+        card = parse_agent_card(response_data)
+        warn_on_missing_required_fields(card, 'v0.3 extended agent card')
+        self.agent_card = card
+        return card
+
+    async def close(self) -> None:
+        """Closes the httpx client unless it is shared."""
+        if self.is_shared_httpx:
+            logger.debug(
+                'Cannot close a shared httpx client; only the provider '
+                'that supplied it via ClientConfig.httpx_client can close it.'
+            )
+            return
+        if self.httpx_client.is_closed:
+            raise A2AClientError('HTTP client is already closed')
+        try:
+            await self.httpx_client.aclose()
+        except Exception as e:
+            raise A2AClientError(f'Failed to close HTTP client: {e}') from e
+
+    def _handle_http_error(self, e: httpx.HTTPStatusError) -> NoReturn:
+        """Handles HTTP status errors and raises the appropriate A2AError."""
+        try:
+            with contextlib.suppress(httpx.StreamClosed):
+                e.response.read()
+
+            try:
+                error_data = e.response.json()
+            except (json.JSONDecodeError, ValueError, httpx.ResponseNotRead):
+                error_data = {}
+            if not isinstance(error_data, dict):
+                error_data = {}
+
+            error_type = error_data.get('type')
+            message = error_data.get('message', str(e))
+
+            if isinstance(error_type, str):
+                exception_cls = _A2A_ERROR_NAME_TO_CLS.get(error_type)
+                if exception_cls:
+                    raise exception_cls(message) from e
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+        status_code = e.response.status_code
+        if status_code == httpx.codes.NOT_FOUND:
+            raise MethodNotFoundError(
+                f'Resource not found: {e.request.url}'
+            ) from e
+
+        raise A2AClientError(f'HTTP Error {status_code}: {e}') from e
+
+    async def _send_stream_request(
+        self,
+        method: str,
+        path: str,
+        context: ClientCallContext | None = None,
+        *,
+        json: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[StreamResponse]:
+        http_kwargs = get_http_args(context)
+        http_kwargs.setdefault('headers', {})
+        http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3
+        add_legacy_extension_header(http_kwargs['headers'])
+
+        async for sse_data in send_http_stream_request(
+            self.httpx_client,
+            method,
+            f'{self.url}{path}',
+            self._handle_http_error,
+            json=json,
+            **http_kwargs,
+        ):
+            event_proto = a2a_v0_3_pb2.StreamResponse()
+            Parse(sse_data, event_proto, ignore_unknown_fields=True)
+            yield conversions.to_core_stream_response(
+                types_v03.SendStreamingMessageSuccessResponse(
+                    result=proto_utils.FromProto.stream_response(event_proto)
+                )
+            )
+
+    async def _send_request(self, request: httpx.Request) -> dict[str, Any]:
+        return await send_http_request(
+            self.httpx_client, request, self._handle_http_error
+        )
+
+    async def _execute_request(
+        self,
+        method: str,
+        path: str,
+        context: ClientCallContext | None = None,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        http_kwargs = get_http_args(context)
+        http_kwargs.setdefault('headers', {})
+        http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3
+        add_legacy_extension_header(http_kwargs['headers'])
+
+        request = self.httpx_client.build_request(
+            method,
+            f'{self.url}{path}',
+            json=json,
+            params=params,
+            **http_kwargs,
+        )
+        return await self._send_request(request)
diff --git a/src/a2a/compat/v0_3/types.py b/src/a2a/compat/v0_3/types.py
new file mode 100644
index 000000000..918a06b5e
--- /dev/null
+++ b/src/a2a/compat/v0_3/types.py
@@ -0,0 +1,2041 @@
+# generated by datamodel-codegen:
+#   filename:  https://raw.githubusercontent.com/a2aproject/A2A/refs/heads/main/specification/json/a2a.json
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import Field, RootModel
+
+from a2a._base import A2ABaseModel
+
+
+class A2A(RootModel[Any]):
+    root: Any
+
+
+class In(str, Enum):
+    """
+    The location of the API key.
+    """
+
+    cookie = 'cookie'
+    header = 'header'
+    query = 'query'
+
+
+class APIKeySecurityScheme(A2ABaseModel):
+    """
+    Defines a security scheme using an API key.
+    """
+
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+    in_: In
+    """
+    The location of the API key.
+    """
+    name: str
+    """
+    The name of the header, query, or cookie parameter to be used.
+    """
+    type: Literal['apiKey'] = 'apiKey'
+    """
+    The type of the security scheme. Must be 'apiKey'.
+    """
+
+
+class AgentCardSignature(A2ABaseModel):
+    """
+    AgentCardSignature represents a JWS signature of an AgentCard.
+    This follows the JSON format of an RFC 7515 JSON Web Signature (JWS).
+    """
+
+    header: dict[str, Any] | None = None
+    """
+    The unprotected JWS header values.
+    """
+    protected: str
+    """
+    The protected JWS header for the signature. This is a Base64url-encoded
+    JSON object, as per RFC 7515.
+    """
+    signature: str
+    """
+    The computed signature, Base64url-encoded.
+    """
+
+
+class AgentExtension(A2ABaseModel):
+    """
+    A declaration of a protocol extension supported by an Agent.
+    """
+
+    description: str | None = None
+    """
+    A human-readable description of how this agent uses the extension.
+    """
+    params: dict[str, Any] | None = None
+    """
+    Optional, extension-specific configuration parameters.
+    """
+    required: bool | None = None
+    """
+    If true, the client must understand and comply with the extension's requirements
+    to interact with the agent.
+    """
+    uri: str
+    """
+    The unique URI identifying the extension.
+    """
+
+
+class AgentInterface(A2ABaseModel):
+    """
+    Declares a combination of a target URL and a transport protocol for interacting with the agent.
+    This allows agents to expose the same functionality over multiple transport mechanisms.
+    """
+
+    transport: str = Field(..., examples=['JSONRPC', 'GRPC', 'HTTP+JSON'])
+    """
+    The transport protocol supported at this URL.
+    """
+    url: str = Field(
+        ...,
+        examples=[
+            'https://api.example.com/a2a/v1',
+            'https://grpc.example.com/a2a',
+            'https://rest.example.com/v1',
+        ],
+    )
+    """
+    The URL where this interface is available. Must be a valid absolute HTTPS URL in production.
+    """
+
+
+class AgentProvider(A2ABaseModel):
+    """
+    Represents the service provider of an agent.
+    """
+
+    organization: str
+    """
+    The name of the agent provider's organization.
+    """
+    url: str
+    """
+    A URL for the agent provider's website or relevant documentation.
+    """
+
+
+class AgentSkill(A2ABaseModel):
+    """
+    Represents a distinct capability or function that an agent can perform.
+    """
+
+    description: str
+    """
+    A detailed description of the skill, intended to help clients or users
+    understand its purpose and functionality.
+    """
+    examples: list[str] | None = Field(
+        default=None, examples=[['I need a recipe for bread']]
+    )
+    """
+    Example prompts or scenarios that this skill can handle. Provides a hint to
+    the client on how to use the skill.
+    """
+    id: str
+    """
+    A unique identifier for the agent's skill.
+    """
+    input_modes: list[str] | None = None
+    """
+    The set of supported input MIME types for this skill, overriding the agent's defaults.
+    """
+    name: str
+    """
+    A human-readable name for the skill.
+    """
+    output_modes: list[str] | None = None
+    """
+    The set of supported output MIME types for this skill, overriding the agent's defaults.
+    """
+    security: list[dict[str, list[str]]] | None = Field(
+        default=None, examples=[[{'google': ['oidc']}]]
+    )
+    """
+    Security schemes necessary for the agent to leverage this skill.
+    As in the overall AgentCard.security, this list represents a logical OR of security
+    requirement objects. Each object is a set of security schemes that must be used together
+    (a logical AND).
+    """
+    tags: list[str] = Field(
+        ..., examples=[['cooking', 'customer support', 'billing']]
+    )
+    """
+    A set of keywords describing the skill's capabilities.
+    """
+
+
+class AuthenticatedExtendedCardNotConfiguredError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the agent does not have an Authenticated Extended Card configured
+    """
+
+    code: Literal[-32007] = -32007
+    """
+    The error code for when an authenticated extended card is not configured.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Authenticated Extended Card is not configured'
+    """
+    The error message.
+    """
+
+
+class AuthorizationCodeOAuthFlow(A2ABaseModel):
+    """
+    Defines configuration details for the OAuth 2.0 Authorization Code flow.
+    """
+
+    authorization_url: str
+    """
+    The authorization URL to be used for this flow.
+    This MUST be a URL and use TLS.
+    """
+    refresh_url: str | None = None
+    """
+    The URL to be used for obtaining refresh tokens.
+    This MUST be a URL and use TLS.
+    """
+    scopes: dict[str, str]
+    """
+    The available scopes for the OAuth2 security scheme. A map between the scope
+    name and a short description for it.
+    """
+    token_url: str
+    """
+    The token URL to be used for this flow.
+    This MUST be a URL and use TLS.
+    """
+
+
+class ClientCredentialsOAuthFlow(A2ABaseModel):
+    """
+    Defines configuration details for the OAuth 2.0 Client Credentials flow.
+    """
+
+    refresh_url: str | None = None
+    """
+    The URL to be used for obtaining refresh tokens. This MUST be a URL.
+    """
+    scopes: dict[str, str]
+    """
+    The available scopes for the OAuth2 security scheme. A map between the scope
+    name and a short description for it.
+    """
+    token_url: str
+    """
+    The token URL to be used for this flow. This MUST be a URL.
+    """
+
+
+class ContentTypeNotSupportedError(A2ABaseModel):
+    """
+    An A2A-specific error indicating an incompatibility between the requested
+    content types and the agent's capabilities.
+    """
+
+    code: Literal[-32005] = -32005
+    """
+    The error code for an unsupported content type.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Incompatible content types'
+    """
+    The error message.
+    """
+
+
+class DataPart(A2ABaseModel):
+    """
+    Represents a structured data segment (e.g., JSON) within a message or artifact.
+    """
+
+    data: dict[str, Any]
+    """
+    The structured data content.
+    """
+    kind: Literal['data'] = 'data'
+    """
+    The type of this part, used as a discriminator. Always 'data'.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with this part.
+    """
+
+
+class DeleteTaskPushNotificationConfigParams(A2ABaseModel):
+    """
+    Defines parameters for deleting a specific push notification configuration for a task.
+    """
+
+    id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with the request.
+    """
+    push_notification_config_id: str
+    """
+    The ID of the push notification configuration to delete.
+    """
+
+
+class DeleteTaskPushNotificationConfigRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/pushNotificationConfig/delete` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/pushNotificationConfig/delete'] = (
+        'tasks/pushNotificationConfig/delete'
+    )
+    """
+    The method name. Must be 'tasks/pushNotificationConfig/delete'.
+    """
+    params: DeleteTaskPushNotificationConfigParams
+    """
+    The parameters identifying the push notification configuration to delete.
+    """
+
+
+class DeleteTaskPushNotificationConfigSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/pushNotificationConfig/delete` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: None
+    """
+    The result is null on successful deletion.
+    """
+
+
+class FileBase(A2ABaseModel):
+    """
+    Defines base properties for a file.
+    """
+
+    mime_type: str | None = None
+    """
+    The MIME type of the file (e.g., "application/pdf").
+    """
+    name: str | None = None
+    """
+    An optional name for the file (e.g., "document.pdf").
+    """
+
+
+class FileWithBytes(A2ABaseModel):
+    """
+    Represents a file with its content provided directly as a base64-encoded string.
+    """
+
+    bytes: str
+    """
+    The base64-encoded content of the file.
+    """
+    mime_type: str | None = None
+    """
+    The MIME type of the file (e.g., "application/pdf").
+    """
+    name: str | None = None
+    """
+    An optional name for the file (e.g., "document.pdf").
+    """
+
+
+class FileWithUri(A2ABaseModel):
+    """
+    Represents a file with its content located at a specific URI.
+    """
+
+    mime_type: str | None = None
+    """
+    The MIME type of the file (e.g., "application/pdf").
+    """
+    name: str | None = None
+    """
+    An optional name for the file (e.g., "document.pdf").
+    """
+    uri: str
+    """
+    A URL pointing to the file's content.
+    """
+
+
+class GetAuthenticatedExtendedCardRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `agent/getAuthenticatedExtendedCard` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['agent/getAuthenticatedExtendedCard'] = (
+        'agent/getAuthenticatedExtendedCard'
+    )
+    """
+    The method name. Must be 'agent/getAuthenticatedExtendedCard'.
+    """
+
+
+class GetTaskPushNotificationConfigParams(A2ABaseModel):
+    """
+    Defines parameters for fetching a specific push notification configuration for a task.
+    """
+
+    id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with the request.
+    """
+    push_notification_config_id: str | None = None
+    """
+    The ID of the push notification configuration to retrieve.
+    """
+
+
+class HTTPAuthSecurityScheme(A2ABaseModel):
+    """
+    Defines a security scheme using HTTP authentication.
+    """
+
+    bearer_format: str | None = None
+    """
+    A hint to the client to identify how the bearer token is formatted (e.g., "JWT").
+    This is primarily for documentation purposes.
+    """
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+    scheme: str
+    """
+    The name of the HTTP Authentication scheme to be used in the Authorization header,
+    as defined in RFC7235 (e.g., "Bearer").
+    This value should be registered in the IANA Authentication Scheme registry.
+    """
+    type: Literal['http'] = 'http'
+    """
+    The type of the security scheme. Must be 'http'.
+    """
+
+
+class ImplicitOAuthFlow(A2ABaseModel):
+    """
+    Defines configuration details for the OAuth 2.0 Implicit flow.
+    """
+
+    authorization_url: str
+    """
+    The authorization URL to be used for this flow. This MUST be a URL.
+    """
+    refresh_url: str | None = None
+    """
+    The URL to be used for obtaining refresh tokens. This MUST be a URL.
+    """
+    scopes: dict[str, str]
+    """
+    The available scopes for the OAuth2 security scheme. A map between the scope
+    name and a short description for it.
+    """
+
+
+class InternalError(A2ABaseModel):
+    """
+    An error indicating an internal error on the server.
+    """
+
+    code: Literal[-32603] = -32603
+    """
+    The error code for an internal server error.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Internal error'
+    """
+    The error message.
+    """
+
+
+class InvalidAgentResponseError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the agent returned a response that
+    does not conform to the specification for the current method.
+    """
+
+    code: Literal[-32006] = -32006
+    """
+    The error code for an invalid agent response.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Invalid agent response'
+    """
+    The error message.
+    """
+
+
+class InvalidParamsError(A2ABaseModel):
+    """
+    An error indicating that the method parameters are invalid.
+    """
+
+    code: Literal[-32602] = -32602
+    """
+    The error code for an invalid parameters error.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Invalid parameters'
+    """
+    The error message.
+    """
+
+
+class InvalidRequestError(A2ABaseModel):
+    """
+    An error indicating that the JSON sent is not a valid Request object.
+    """
+
+    code: Literal[-32600] = -32600
+    """
+    The error code for an invalid request.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Request payload validation error'
+    """
+    The error message.
+    """
+
+
+class JSONParseError(A2ABaseModel):
+    """
+    An error indicating that the server received invalid JSON.
+    """
+
+    code: Literal[-32700] = -32700
+    """
+    The error code for a JSON parse error.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Invalid JSON payload'
+    """
+    The error message.
+    """
+
+
+class JSONRPCError(A2ABaseModel):
+    """
+    Represents a JSON-RPC 2.0 Error object, included in an error response.
+    """
+
+    code: int
+    """
+    A number that indicates the error type that occurred.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str
+    """
+    A string providing a short description of the error.
+    """
+
+
+class JSONRPCMessage(A2ABaseModel):
+    """
+    Defines the base structure for any JSON-RPC 2.0 request, response, or notification.
+    """
+
+    id: str | int | None = None
+    """
+    A unique identifier established by the client. It must be a String, a Number, or null.
+    The server must reply with the same value in the response. This property is omitted for notifications.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+
+
+class JSONRPCRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC 2.0 Request object.
+    """
+
+    id: str | int | None = None
+    """
+    A unique identifier established by the client. It must be a String, a Number, or null.
+    The server must reply with the same value in the response. This property is omitted for notifications.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: str
+    """
+    A string containing the name of the method to be invoked.
+    """
+    params: dict[str, Any] | None = None
+    """
+    A structured value holding the parameter values to be used during the method invocation.
+    """
+
+
+class JSONRPCSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC 2.0 Response object.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: Any
+    """
+    The value of this member is determined by the method invoked on the Server.
+    """
+
+
+class ListTaskPushNotificationConfigParams(A2ABaseModel):
+    """
+    Defines parameters for listing all push notification configurations associated with a task.
+    """
+
+    id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with the request.
+    """
+
+
+class ListTaskPushNotificationConfigRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/pushNotificationConfig/list` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/pushNotificationConfig/list'] = (
+        'tasks/pushNotificationConfig/list'
+    )
+    """
+    The method name. Must be 'tasks/pushNotificationConfig/list'.
+    """
+    params: ListTaskPushNotificationConfigParams
+    """
+    The parameters identifying the task whose configurations are to be listed.
+    """
+
+
+class Role(str, Enum):
+    """
+    Identifies the sender of the message. `user` for the client, `agent` for the service.
+    """
+
+    agent = 'agent'
+    user = 'user'
+
+
+class MethodNotFoundError(A2ABaseModel):
+    """
+    An error indicating that the requested method does not exist or is not available.
+    """
+
+    code: Literal[-32601] = -32601
+    """
+    The error code for a method not found error.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Method not found'
+    """
+    The error message.
+    """
+
+
+class MutualTLSSecurityScheme(A2ABaseModel):
+    """
+    Defines a security scheme using mTLS authentication.
+    """
+
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+    type: Literal['mutualTLS'] = 'mutualTLS'
+    """
+    The type of the security scheme. Must be 'mutualTLS'.
+    """
+
+
+class OpenIdConnectSecurityScheme(A2ABaseModel):
+    """
+    Defines a security scheme using OpenID Connect.
+    """
+
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+    open_id_connect_url: str
+    """
+    The OpenID Connect Discovery URL for the OIDC provider's metadata.
+    """
+    type: Literal['openIdConnect'] = 'openIdConnect'
+    """
+    The type of the security scheme. Must be 'openIdConnect'.
+    """
+
+
+class PartBase(A2ABaseModel):
+    """
+    Defines base properties common to all message or artifact parts.
+    """
+
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with this part.
+    """
+
+
+class PasswordOAuthFlow(A2ABaseModel):
+    """
+    Defines configuration details for the OAuth 2.0 Resource Owner Password flow.
+    """
+
+    refresh_url: str | None = None
+    """
+    The URL to be used for obtaining refresh tokens. This MUST be a URL.
+    """
+    scopes: dict[str, str]
+    """
+    The available scopes for the OAuth2 security scheme. A map between the scope
+    name and a short description for it.
+    """
+    token_url: str
+    """
+    The token URL to be used for this flow. This MUST be a URL.
+    """
+
+
+class PushNotificationAuthenticationInfo(A2ABaseModel):
+    """
+    Defines authentication details for a push notification endpoint.
+    """
+
+    credentials: str | None = None
+    """
+    Optional credentials required by the push notification endpoint.
+    """
+    schemes: list[str]
+    """
+    A list of supported authentication schemes (e.g., 'Basic', 'Bearer').
+    """
+
+
+class PushNotificationConfig(A2ABaseModel):
+    """
+    Defines the configuration for setting up push notifications for task updates.
+    """
+
+    authentication: PushNotificationAuthenticationInfo | None = None
+    """
+    Optional authentication details for the agent to use when calling the notification URL.
+    """
+    id: str | None = None
+    """
+    A unique identifier (e.g. UUID) for the push notification configuration, set by the client
+    to support multiple notification callbacks.
+    """
+    token: str | None = None
+    """
+    A unique token for this task or session to validate incoming push notifications.
+    """
+    url: str
+    """
+    The callback URL where the agent should send push notifications.
+    """
+
+
+class PushNotificationNotSupportedError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the agent does not support push notifications.
+    """
+
+    code: Literal[-32003] = -32003
+    """
+    The error code for when push notifications are not supported.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Push Notification is not supported'
+    """
+    The error message.
+    """
+
+
+class SecuritySchemeBase(A2ABaseModel):
+    """
+    Defines base properties shared by all security scheme objects.
+    """
+
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+
+
+class TaskIdParams(A2ABaseModel):
+    """
+    Defines parameters containing a task ID, used for simple task operations.
+    """
+
+    id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with the request.
+    """
+
+
+class TaskNotCancelableError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the task is in a state where it cannot be canceled.
+    """
+
+    code: Literal[-32002] = -32002
+    """
+    The error code for a task that cannot be canceled.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Task cannot be canceled'
+    """
+    The error message.
+    """
+
+
+class TaskNotFoundError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the requested task ID was not found.
+    """
+
+    code: Literal[-32001] = -32001
+    """
+    The error code for a task not found error.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'Task not found'
+    """
+    The error message.
+    """
+
+
+class TaskPushNotificationConfig(A2ABaseModel):
+    """
+    A container associating a push notification configuration with a specific task.
+    """
+
+    push_notification_config: PushNotificationConfig
+    """
+    The push notification configuration for this task.
+    """
+    task_id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+
+
+class TaskQueryParams(A2ABaseModel):
+    """
+    Defines parameters for querying a task, with an option to limit history length.
+    """
+
+    history_length: int | None = None
+    """
+    The number of most recent messages from the task's history to retrieve.
+    """
+    id: str
+    """
+    The unique identifier (e.g. UUID) of the task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with the request.
+    """
+
+
+class TaskResubscriptionRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/resubscribe` method, used to resume a streaming connection.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/resubscribe'] = 'tasks/resubscribe'
+    """
+    The method name. Must be 'tasks/resubscribe'.
+    """
+    params: TaskIdParams
+    """
+    The parameters identifying the task to resubscribe to.
+    """
+
+
+class TaskState(str, Enum):
+    """
+    Defines the lifecycle states of a Task.
+    """
+
+    submitted = 'submitted'
+    working = 'working'
+    input_required = 'input-required'
+    completed = 'completed'
+    canceled = 'canceled'
+    failed = 'failed'
+    rejected = 'rejected'
+    auth_required = 'auth-required'
+    unknown = 'unknown'
+
+
+class TextPart(A2ABaseModel):
+    """
+    Represents a text segment within a message or artifact.
+    """
+
+    kind: Literal['text'] = 'text'
+    """
+    The type of this part, used as a discriminator. Always 'text'.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with this part.
+    """
+    text: str
+    """
+    The string content of the text part.
+    """
+
+
+class TransportProtocol(str, Enum):
+    """
+    Supported A2A transport protocols.
+    """
+
+    jsonrpc = 'JSONRPC'
+    grpc = 'GRPC'
+    http_json = 'HTTP+JSON'
+
+
+class UnsupportedOperationError(A2ABaseModel):
+    """
+    An A2A-specific error indicating that the requested operation is not supported by the agent.
+    """
+
+    code: Literal[-32004] = -32004
+    """
+    The error code for an unsupported operation.
+    """
+    data: Any | None = None
+    """
+    A primitive or structured value containing additional information about the error.
+    This may be omitted.
+    """
+    message: str | None = 'This operation is not supported'
+    """
+    The error message.
+    """
+
+
+class A2AError(
+    RootModel[
+        JSONParseError
+        | InvalidRequestError
+        | MethodNotFoundError
+        | InvalidParamsError
+        | InternalError
+        | TaskNotFoundError
+        | TaskNotCancelableError
+        | PushNotificationNotSupportedError
+        | UnsupportedOperationError
+        | ContentTypeNotSupportedError
+        | InvalidAgentResponseError
+        | AuthenticatedExtendedCardNotConfiguredError
+    ]
+):
+    root: (
+        JSONParseError
+        | InvalidRequestError
+        | MethodNotFoundError
+        | InvalidParamsError
+        | InternalError
+        | TaskNotFoundError
+        | TaskNotCancelableError
+        | PushNotificationNotSupportedError
+        | UnsupportedOperationError
+        | ContentTypeNotSupportedError
+        | InvalidAgentResponseError
+        | AuthenticatedExtendedCardNotConfiguredError
+    )
+    """
+    A discriminated union of all standard JSON-RPC and A2A-specific error types.
+    """
+
+
+class AgentCapabilities(A2ABaseModel):
+    """
+    Defines optional capabilities supported by an agent.
+    """
+
+    extensions: list[AgentExtension] | None = None
+    """
+    A list of protocol extensions supported by the agent.
+    """
+    push_notifications: bool | None = None
+    """
+    Indicates if the agent supports sending push notifications for asynchronous task updates.
+    """
+    state_transition_history: bool | None = None
+    """
+    Indicates if the agent provides a history of state transitions for a task.
+    """
+    streaming: bool | None = None
+    """
+    Indicates if the agent supports Server-Sent Events (SSE) for streaming responses.
+    """
+
+
+class CancelTaskRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/cancel` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/cancel'] = 'tasks/cancel'
+    """
+    The method name. Must be 'tasks/cancel'.
+    """
+    params: TaskIdParams
+    """
+    The parameters identifying the task to cancel.
+    """
+
+
+class FilePart(A2ABaseModel):
+    """
+    Represents a file segment within a message or artifact. The file content can be
+    provided either directly as bytes or as a URI.
+    """
+
+    file: FileWithBytes | FileWithUri
+    """
+    The file content, represented as either a URI or as base64-encoded bytes.
+    """
+    kind: Literal['file'] = 'file'
+    """
+    The type of this part, used as a discriminator. Always 'file'.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata associated with this part.
+    """
+
+
+class GetTaskPushNotificationConfigRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/pushNotificationConfig/get` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/pushNotificationConfig/get'] = (
+        'tasks/pushNotificationConfig/get'
+    )
+    """
+    The method name. Must be 'tasks/pushNotificationConfig/get'.
+    """
+    params: TaskIdParams | GetTaskPushNotificationConfigParams
+    """
+    The parameters for getting a push notification configuration.
+    """
+
+
+class GetTaskPushNotificationConfigSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/pushNotificationConfig/get` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: TaskPushNotificationConfig
+    """
+    The result, containing the requested push notification configuration.
+    """
+
+
+class GetTaskRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/get` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/get'] = 'tasks/get'
+    """
+    The method name. Must be 'tasks/get'.
+    """
+    params: TaskQueryParams
+    """
+    The parameters for querying a task.
+    """
+
+
+class JSONRPCErrorResponse(A2ABaseModel):
+    """
+    Represents a JSON-RPC 2.0 Error Response object.
+    """
+
+    error: (
+        JSONRPCError
+        | JSONParseError
+        | InvalidRequestError
+        | MethodNotFoundError
+        | InvalidParamsError
+        | InternalError
+        | TaskNotFoundError
+        | TaskNotCancelableError
+        | PushNotificationNotSupportedError
+        | UnsupportedOperationError
+        | ContentTypeNotSupportedError
+        | InvalidAgentResponseError
+        | AuthenticatedExtendedCardNotConfiguredError
+    )
+    """
+    An object describing the error that occurred.
+    """
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+
+
+class ListTaskPushNotificationConfigSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/pushNotificationConfig/list` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: list[TaskPushNotificationConfig]
+    """
+    The result, containing an array of all push notification configurations for the task.
+    """
+
+
+class MessageSendConfiguration(A2ABaseModel):
+    """
+    Defines configuration options for a `message/send` or `message/stream` request.
+    """
+
+    accepted_output_modes: list[str] | None = None
+    """
+    A list of output MIME types the client is prepared to accept in the response.
+    """
+    blocking: bool | None = None
+    """
+    If true, the client will wait for the task to complete. The server may reject this if the task is long-running.
+    """
+    history_length: int | None = None
+    """
+    The number of most recent messages from the task's history to retrieve in the response.
+    """
+    push_notification_config: PushNotificationConfig | None = None
+    """
+    Configuration for the agent to send push notifications for updates after the initial response.
+    """
+
+
+class OAuthFlows(A2ABaseModel):
+    """
+    Defines the configuration for the supported OAuth 2.0 flows.
+    """
+
+    authorization_code: AuthorizationCodeOAuthFlow | None = None
+    """
+    Configuration for the OAuth Authorization Code flow. Previously called accessCode in OpenAPI 2.0.
+    """
+    client_credentials: ClientCredentialsOAuthFlow | None = None
+    """
+    Configuration for the OAuth Client Credentials flow. Previously called application in OpenAPI 2.0.
+    """
+    implicit: ImplicitOAuthFlow | None = None
+    """
+    Configuration for the OAuth Implicit flow.
+    """
+    password: PasswordOAuthFlow | None = None
+    """
+    Configuration for the OAuth Resource Owner Password flow.
+    """
+
+
+class Part(RootModel[TextPart | FilePart | DataPart]):
+    root: TextPart | FilePart | DataPart
+    """
+    A discriminated union representing a part of a message or artifact, which can
+    be text, a file, or structured data.
+    """
+
+
+class SetTaskPushNotificationConfigRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `tasks/pushNotificationConfig/set` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['tasks/pushNotificationConfig/set'] = (
+        'tasks/pushNotificationConfig/set'
+    )
+    """
+    The method name. Must be 'tasks/pushNotificationConfig/set'.
+    """
+    params: TaskPushNotificationConfig
+    """
+    The parameters for setting the push notification configuration.
+    """
+
+
+class SetTaskPushNotificationConfigSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/pushNotificationConfig/set` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: TaskPushNotificationConfig
+    """
+    The result, containing the configured push notification settings.
+    """
+
+
+class Artifact(A2ABaseModel):
+    """
+    Represents a file, data structure, or other resource generated by an agent during a task.
+    """
+
+    artifact_id: str
+    """
+    A unique identifier (e.g. UUID) for the artifact within the scope of the task.
+    """
+    description: str | None = None
+    """
+    An optional, human-readable description of the artifact.
+    """
+    extensions: list[str] | None = None
+    """
+    The URIs of extensions that are relevant to this artifact.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions. The key is an extension-specific identifier.
+    """
+    name: str | None = None
+    """
+    An optional, human-readable name for the artifact.
+    """
+    parts: list[Part]
+    """
+    An array of content parts that make up the artifact.
+    """
+
+
+class DeleteTaskPushNotificationConfigResponse(
+    RootModel[
+        JSONRPCErrorResponse | DeleteTaskPushNotificationConfigSuccessResponse
+    ]
+):
+    root: JSONRPCErrorResponse | DeleteTaskPushNotificationConfigSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/pushNotificationConfig/delete` method.
+    """
+
+
+class GetTaskPushNotificationConfigResponse(
+    RootModel[
+        JSONRPCErrorResponse | GetTaskPushNotificationConfigSuccessResponse
+    ]
+):
+    root: JSONRPCErrorResponse | GetTaskPushNotificationConfigSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/pushNotificationConfig/get` method.
+    """
+
+
+class ListTaskPushNotificationConfigResponse(
+    RootModel[
+        JSONRPCErrorResponse | ListTaskPushNotificationConfigSuccessResponse
+    ]
+):
+    root: JSONRPCErrorResponse | ListTaskPushNotificationConfigSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/pushNotificationConfig/list` method.
+    """
+
+
+class Message(A2ABaseModel):
+    """
+    Represents a single message in the conversation between a user and an agent.
+    """
+
+    context_id: str | None = None
+    """
+    The context ID for this message, used to group related interactions.
+    """
+    extensions: list[str] | None = None
+    """
+    The URIs of extensions that are relevant to this message.
+    """
+    kind: Literal['message'] = 'message'
+    """
+    The type of this object, used as a discriminator. Always 'message' for a Message.
+    """
+    message_id: str
+    """
+    A unique identifier for the message, typically a UUID, generated by the sender.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions. The key is an extension-specific identifier.
+    """
+    parts: list[Part]
+    """
+    An array of content parts that form the message body. A message can be
+    composed of multiple parts of different types (e.g., text and files).
+    """
+    reference_task_ids: list[str] | None = None
+    """
+    A list of other task IDs that this message references for additional context.
+    """
+    role: Role
+    """
+    Identifies the sender of the message. `user` for the client, `agent` for the service.
+    """
+    task_id: str | None = None
+    """
+    The ID of the task this message is part of. Can be omitted for the first message of a new task.
+    """
+
+
+class MessageSendParams(A2ABaseModel):
+    """
+    Defines the parameters for a request to send a message to an agent. This can be used
+    to create a new task, continue an existing one, or restart a task.
+    """
+
+    configuration: MessageSendConfiguration | None = None
+    """
+    Optional configuration for the send request.
+    """
+    message: Message
+    """
+    The message object being sent to the agent.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions.
+    """
+
+
+class OAuth2SecurityScheme(A2ABaseModel):
+    """
+    Defines a security scheme using OAuth 2.0.
+    """
+
+    description: str | None = None
+    """
+    An optional description for the security scheme.
+    """
+    flows: OAuthFlows
+    """
+    An object containing configuration information for the supported OAuth 2.0 flows.
+    """
+    oauth2_metadata_url: str | None = None
+    """
+    URL to the oauth2 authorization server metadata
+    [RFC8414](https://datatracker.ietf.org/doc/html/rfc8414). TLS is required.
+    """
+    type: Literal['oauth2'] = 'oauth2'
+    """
+    The type of the security scheme. Must be 'oauth2'.
+    """
+
+
+class SecurityScheme(
+    RootModel[
+        APIKeySecurityScheme
+        | HTTPAuthSecurityScheme
+        | OAuth2SecurityScheme
+        | OpenIdConnectSecurityScheme
+        | MutualTLSSecurityScheme
+    ]
+):
+    root: (
+        APIKeySecurityScheme
+        | HTTPAuthSecurityScheme
+        | OAuth2SecurityScheme
+        | OpenIdConnectSecurityScheme
+        | MutualTLSSecurityScheme
+    )
+    """
+    Defines a security scheme that can be used to secure an agent's endpoints.
+    This is a discriminated union type based on the OpenAPI 3.0 Security Scheme Object.
+    """
+
+
+class SendMessageRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `message/send` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['message/send'] = 'message/send'
+    """
+    The method name. Must be 'message/send'.
+    """
+    params: MessageSendParams
+    """
+    The parameters for sending a message.
+    """
+
+
+class SendStreamingMessageRequest(A2ABaseModel):
+    """
+    Represents a JSON-RPC request for the `message/stream` method.
+    """
+
+    id: str | int
+    """
+    The identifier for this request.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    method: Literal['message/stream'] = 'message/stream'
+    """
+    The method name. Must be 'message/stream'.
+    """
+    params: MessageSendParams
+    """
+    The parameters for sending a message.
+    """
+
+
+class SetTaskPushNotificationConfigResponse(
+    RootModel[
+        JSONRPCErrorResponse | SetTaskPushNotificationConfigSuccessResponse
+    ]
+):
+    root: JSONRPCErrorResponse | SetTaskPushNotificationConfigSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/pushNotificationConfig/set` method.
+    """
+
+
+class TaskArtifactUpdateEvent(A2ABaseModel):
+    """
+    An event sent by the agent to notify the client that an artifact has been
+    generated or updated. This is typically used in streaming models.
+    """
+
+    append: bool | None = None
+    """
+    If true, the content of this artifact should be appended to a previously sent artifact with the same ID.
+    """
+    artifact: Artifact
+    """
+    The artifact that was generated or updated.
+    """
+    context_id: str
+    """
+    The context ID associated with the task.
+    """
+    kind: Literal['artifact-update'] = 'artifact-update'
+    """
+    The type of this event, used as a discriminator. Always 'artifact-update'.
+    """
+    last_chunk: bool | None = None
+    """
+    If true, this is the final chunk of the artifact.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions.
+    """
+    task_id: str
+    """
+    The ID of the task this artifact belongs to.
+    """
+
+
+class TaskStatus(A2ABaseModel):
+    """
+    Represents the status of a task at a specific point in time.
+    """
+
+    message: Message | None = None
+    """
+    An optional, human-readable message providing more details about the current status.
+    """
+    state: TaskState
+    """
+    The current state of the task's lifecycle.
+    """
+    timestamp: str | None = Field(
+        default=None, examples=['2023-10-27T10:00:00Z']
+    )
+    """
+    An ISO 8601 datetime string indicating when this status was recorded.
+    """
+
+
+class TaskStatusUpdateEvent(A2ABaseModel):
+    """
+    An event sent by the agent to notify the client of a change in a task's status.
+    This is typically used in streaming or subscription models.
+    """
+
+    context_id: str
+    """
+    The context ID associated with the task.
+    """
+    final: bool
+    """
+    If true, this is the final event in the stream for this interaction.
+    """
+    kind: Literal['status-update'] = 'status-update'
+    """
+    The type of this event, used as a discriminator. Always 'status-update'.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions.
+    """
+    status: TaskStatus
+    """
+    The new status of the task.
+    """
+    task_id: str
+    """
+    The ID of the task that was updated.
+    """
+
+
+class A2ARequest(
+    RootModel[
+        SendMessageRequest
+        | SendStreamingMessageRequest
+        | GetTaskRequest
+        | CancelTaskRequest
+        | SetTaskPushNotificationConfigRequest
+        | GetTaskPushNotificationConfigRequest
+        | TaskResubscriptionRequest
+        | ListTaskPushNotificationConfigRequest
+        | DeleteTaskPushNotificationConfigRequest
+        | GetAuthenticatedExtendedCardRequest
+    ]
+):
+    root: (
+        SendMessageRequest
+        | SendStreamingMessageRequest
+        | GetTaskRequest
+        | CancelTaskRequest
+        | SetTaskPushNotificationConfigRequest
+        | GetTaskPushNotificationConfigRequest
+        | TaskResubscriptionRequest
+        | ListTaskPushNotificationConfigRequest
+        | DeleteTaskPushNotificationConfigRequest
+        | GetAuthenticatedExtendedCardRequest
+    )
+    """
+    A discriminated union representing all possible JSON-RPC 2.0 requests supported by the A2A specification.
+    """
+
+
+class AgentCard(A2ABaseModel):
+    """
+    The AgentCard is a self-describing manifest for an agent. It provides essential
+    metadata including the agent's identity, capabilities, skills, supported
+    communication methods, and security requirements.
+    """
+
+    additional_interfaces: list[AgentInterface] | None = None
+    """
+    A list of additional supported interfaces (transport and URL combinations).
+    This allows agents to expose multiple transports, potentially at different URLs.
+
+    Best practices:
+    - SHOULD include all supported transports for completeness
+    - SHOULD include an entry matching the main 'url' and 'preferredTransport'
+    - MAY reuse URLs if multiple transports are available at the same endpoint
+    - MUST accurately declare the transport available at each URL
+
+    Clients can select any interface from this list based on their transport capabilities
+    and preferences. This enables transport negotiation and fallback scenarios.
+    """
+    capabilities: AgentCapabilities
+    """
+    A declaration of optional capabilities supported by the agent.
+    """
+    default_input_modes: list[str]
+    """
+    Default set of supported input MIME types for all skills, which can be
+    overridden on a per-skill basis.
+    """
+    default_output_modes: list[str]
+    """
+    Default set of supported output MIME types for all skills, which can be
+    overridden on a per-skill basis.
+    """
+    description: str = Field(
+        ..., examples=['Agent that helps users with recipes and cooking.']
+    )
+    """
+    A human-readable description of the agent, assisting users and other agents
+    in understanding its purpose.
+    """
+    documentation_url: str | None = None
+    """
+    An optional URL to the agent's documentation.
+    """
+    icon_url: str | None = None
+    """
+    An optional URL to an icon for the agent.
+    """
+    name: str = Field(..., examples=['Recipe Agent'])
+    """
+    A human-readable name for the agent.
+    """
+    preferred_transport: str | None = Field(
+        default='JSONRPC', examples=['JSONRPC', 'GRPC', 'HTTP+JSON']
+    )
+    """
+    The transport protocol for the preferred endpoint (the main 'url' field).
+    If not specified, defaults to 'JSONRPC'.
+
+    IMPORTANT: The transport specified here MUST be available at the main 'url'.
+    This creates a binding between the main URL and its supported transport protocol.
+    Clients should prefer this transport and URL combination when both are supported.
+    """
+    protocol_version: str | None = '0.3.0'
+    """
+    The version of the A2A protocol this agent supports.
+    """
+    provider: AgentProvider | None = None
+    """
+    Information about the agent's service provider.
+    """
+    security: list[dict[str, list[str]]] | None = Field(
+        default=None,
+        examples=[[{'oauth': ['read']}, {'api-key': [], 'mtls': []}]],
+    )
+    """
+    A list of security requirement objects that apply to all agent interactions. Each object
+    lists security schemes that can be used. Follows the OpenAPI 3.0 Security Requirement Object.
+    This list can be seen as an OR of ANDs. Each object in the list describes one possible
+    set of security requirements that must be present on a request. This allows specifying,
+    for example, "callers must either use OAuth OR an API Key AND mTLS."
+    """
+    security_schemes: dict[str, SecurityScheme] | None = None
+    """
+    A declaration of the security schemes available to authorize requests. The key is the
+    scheme name. Follows the OpenAPI 3.0 Security Scheme Object.
+    """
+    signatures: list[AgentCardSignature] | None = None
+    """
+    JSON Web Signatures computed for this AgentCard.
+    """
+    skills: list[AgentSkill]
+    """
+    The set of skills, or distinct capabilities, that the agent can perform.
+    """
+    supports_authenticated_extended_card: bool | None = None
+    """
+    If true, the agent can provide an extended agent card with additional details
+    to authenticated users. Defaults to false.
+    """
+    url: str = Field(..., examples=['https://api.example.com/a2a/v1'])
+    """
+    The preferred endpoint URL for interacting with the agent.
+    This URL MUST support the transport specified by 'preferredTransport'.
+    """
+    version: str = Field(..., examples=['1.0.0'])
+    """
+    The agent's own version number. The format is defined by the provider.
+    """
+
+
+class GetAuthenticatedExtendedCardSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `agent/getAuthenticatedExtendedCard` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: AgentCard
+    """
+    The result is an Agent Card object.
+    """
+
+
+class Task(A2ABaseModel):
+    """
+    Represents a single, stateful operation or conversation between a client and an agent.
+    """
+
+    artifacts: list[Artifact] | None = None
+    """
+    A collection of artifacts generated by the agent during the execution of the task.
+    """
+    context_id: str
+    """
+    A server-generated unique identifier (e.g. UUID) for maintaining context across multiple related tasks or interactions.
+    """
+    history: list[Message] | None = None
+    """
+    An array of messages exchanged during the task, representing the conversation history.
+    """
+    id: str
+    """
+    A unique identifier (e.g. UUID) for the task, generated by the server for a new task.
+    """
+    kind: Literal['task'] = 'task'
+    """
+    The type of this object, used as a discriminator. Always 'task' for a Task.
+    """
+    metadata: dict[str, Any] | None = None
+    """
+    Optional metadata for extensions. The key is an extension-specific identifier.
+    """
+    status: TaskStatus
+    """
+    The current status of the task, including its state and a descriptive message.
+    """
+
+
+class CancelTaskSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/cancel` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: Task
+    """
+    The result, containing the final state of the canceled Task object.
+    """
+
+
+class GetAuthenticatedExtendedCardResponse(
+    RootModel[
+        JSONRPCErrorResponse | GetAuthenticatedExtendedCardSuccessResponse
+    ]
+):
+    root: JSONRPCErrorResponse | GetAuthenticatedExtendedCardSuccessResponse
+    """
+    Represents a JSON-RPC response for the `agent/getAuthenticatedExtendedCard` method.
+    """
+
+
+class GetTaskSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `tasks/get` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: Task
+    """
+    The result, containing the requested Task object.
+    """
+
+
+class SendMessageSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `message/send` method.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: Task | Message
+    """
+    The result, which can be a direct reply Message or the initial Task object.
+    """
+
+
+class SendStreamingMessageSuccessResponse(A2ABaseModel):
+    """
+    Represents a successful JSON-RPC response for the `message/stream` method.
+    The server may send multiple response objects for a single request.
+    """
+
+    id: str | int | None = None
+    """
+    The identifier established by the client.
+    """
+    jsonrpc: Literal['2.0'] = '2.0'
+    """
+    The version of the JSON-RPC protocol. MUST be exactly "2.0".
+    """
+    result: Task | Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+    """
+    The result, which can be a Message, Task, or a streaming update event.
+    """
+
+
+class CancelTaskResponse(
+    RootModel[JSONRPCErrorResponse | CancelTaskSuccessResponse]
+):
+    root: JSONRPCErrorResponse | CancelTaskSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/cancel` method.
+    """
+
+
+class GetTaskResponse(RootModel[JSONRPCErrorResponse | GetTaskSuccessResponse]):
+    root: JSONRPCErrorResponse | GetTaskSuccessResponse
+    """
+    Represents a JSON-RPC response for the `tasks/get` method.
+    """
+
+
+class JSONRPCResponse(
+    RootModel[
+        JSONRPCErrorResponse
+        | SendMessageSuccessResponse
+        | SendStreamingMessageSuccessResponse
+        | GetTaskSuccessResponse
+        | CancelTaskSuccessResponse
+        | SetTaskPushNotificationConfigSuccessResponse
+        | GetTaskPushNotificationConfigSuccessResponse
+        | ListTaskPushNotificationConfigSuccessResponse
+        | DeleteTaskPushNotificationConfigSuccessResponse
+        | GetAuthenticatedExtendedCardSuccessResponse
+    ]
+):
+    root: (
+        JSONRPCErrorResponse
+        | SendMessageSuccessResponse
+        | SendStreamingMessageSuccessResponse
+        | GetTaskSuccessResponse
+        | CancelTaskSuccessResponse
+        | SetTaskPushNotificationConfigSuccessResponse
+        | GetTaskPushNotificationConfigSuccessResponse
+        | ListTaskPushNotificationConfigSuccessResponse
+        | DeleteTaskPushNotificationConfigSuccessResponse
+        | GetAuthenticatedExtendedCardSuccessResponse
+    )
+    """
+    A discriminated union representing all possible JSON-RPC 2.0 responses
+    for the A2A specification methods.
+    """
+
+
+class SendMessageResponse(
+    RootModel[JSONRPCErrorResponse | SendMessageSuccessResponse]
+):
+    root: JSONRPCErrorResponse | SendMessageSuccessResponse
+    """
+    Represents a JSON-RPC response for the `message/send` method.
+    """
+
+
+class SendStreamingMessageResponse(
+    RootModel[JSONRPCErrorResponse | SendStreamingMessageSuccessResponse]
+):
+    root: JSONRPCErrorResponse | SendStreamingMessageSuccessResponse
+    """
+    Represents a JSON-RPC response for the `message/stream` method.
+    """
diff --git a/src/a2a/compat/v0_3/versions.py b/src/a2a/compat/v0_3/versions.py
new file mode 100644
index 000000000..67808d5f2
--- /dev/null
+++ b/src/a2a/compat/v0_3/versions.py
@@ -0,0 +1,18 @@
+"""Utility functions for protocol version comparison and validation."""
+
+from packaging.version import InvalidVersion, Version
+
+from a2a.utils.constants import PROTOCOL_VERSION_0_3, PROTOCOL_VERSION_1_0
+
+
+def is_legacy_version(version: str | None) -> bool:
+    """Determines if the given version is a legacy protocol version (>=0.3 and <1.0)."""
+    if not version:
+        return False
+    try:
+        v = Version(version)
+        return (
+            Version(PROTOCOL_VERSION_0_3) <= v < Version(PROTOCOL_VERSION_1_0)
+        )
+    except InvalidVersion:
+        return False
diff --git a/src/a2a/extensions/__init__.py b/src/a2a/extensions/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/a2a/extensions/common.py b/src/a2a/extensions/common.py
new file mode 100644
index 000000000..06ccf8f40
--- /dev/null
+++ b/src/a2a/extensions/common.py
@@ -0,0 +1,27 @@
+from a2a.types.a2a_pb2 import AgentCard, AgentExtension
+
+
+HTTP_EXTENSION_HEADER = 'A2A-Extensions'
+
+
+def get_requested_extensions(values: list[str]) -> set[str]:
+    """Get the set of requested extensions from an input list.
+
+    This handles the list containing potentially comma-separated values, as
+    occurs when using a list in an HTTP header.
+    """
+    return {
+        stripped
+        for v in values
+        for ext in v.split(',')
+        if (stripped := ext.strip())
+    }
+
+
+def find_extension_by_uri(card: AgentCard, uri: str) -> AgentExtension | None:
+    """Find an AgentExtension in an AgentCard given a uri."""
+    for ext in card.capabilities.extensions or []:
+        if ext.uri == uri:
+            return ext
+
+    return None
diff --git a/src/a2a/helpers/__init__.py b/src/a2a/helpers/__init__.py
new file mode 100644
index 000000000..a4a0401e7
--- /dev/null
+++ b/src/a2a/helpers/__init__.py
@@ -0,0 +1,66 @@
+"""Helper functions for the A2A Python SDK."""
+
+from a2a.helpers.agent_card import display_agent_card
+from a2a.helpers.proto_helpers import (
+    get_artifact_text,
+    get_data_parts,
+    get_message_text,
+    get_raw_parts,
+    get_stream_response_text,
+    get_text_parts,
+    get_url_parts,
+    new_artifact,
+    new_data_artifact,
+    new_data_artifact_update_event,
+    new_data_message,
+    new_data_part,
+    new_message,
+    new_raw_artifact,
+    new_raw_artifact_update_event,
+    new_raw_message,
+    new_raw_part,
+    new_task,
+    new_task_from_user_message,
+    new_text_artifact,
+    new_text_artifact_update_event,
+    new_text_message,
+    new_text_part,
+    new_text_status_update_event,
+    new_url_artifact,
+    new_url_artifact_update_event,
+    new_url_message,
+    new_url_part,
+)
+
+
+__all__ = [
+    'display_agent_card',
+    'get_artifact_text',
+    'get_data_parts',
+    'get_message_text',
+    'get_raw_parts',
+    'get_stream_response_text',
+    'get_text_parts',
+    'get_url_parts',
+    'new_artifact',
+    'new_data_artifact',
+    'new_data_artifact_update_event',
+    'new_data_message',
+    'new_data_part',
+    'new_message',
+    'new_raw_artifact',
+    'new_raw_artifact_update_event',
+    'new_raw_message',
+    'new_raw_part',
+    'new_task',
+    'new_task_from_user_message',
+    'new_text_artifact',
+    'new_text_artifact_update_event',
+    'new_text_message',
+    'new_text_part',
+    'new_text_status_update_event',
+    'new_url_artifact',
+    'new_url_artifact_update_event',
+    'new_url_message',
+    'new_url_part',
+]
diff --git a/src/a2a/helpers/agent_card.py b/src/a2a/helpers/agent_card.py
new file mode 100644
index 000000000..0962e67fb
--- /dev/null
+++ b/src/a2a/helpers/agent_card.py
@@ -0,0 +1,76 @@
+"""Utility functions for inspecting AgentCard instances."""
+
+from a2a.types.a2a_pb2 import AgentCard
+
+
+def display_agent_card(card: AgentCard) -> None:
+    """Print a human-readable summary of an AgentCard to stdout.
+
+    Args:
+        card: The AgentCard proto message to display.
+    """
+    width = 52
+    sep = '=' * width
+    thin = '-' * width
+
+    lines: list[str] = [sep, 'AgentCard'.center(width), sep]
+
+    lines += [
+        '--- General ---',
+        f'Name        : {card.name}',
+        f'Description : {card.description}',
+        f'Version     : {card.version}',
+    ]
+    if card.documentation_url:
+        lines.append(f'Docs URL    : {card.documentation_url}')
+    if card.icon_url:
+        lines.append(f'Icon URL    : {card.icon_url}')
+    if card.HasField('provider'):
+        url_suffix = f' ({card.provider.url})' if card.provider.url else ''
+        lines.append(f'Provider    : {card.provider.organization}{url_suffix}')
+
+    lines += ['', '--- Interfaces ---']
+    for i, iface in enumerate(card.supported_interfaces):
+        binding = f'{iface.protocol_binding} {iface.protocol_version}'.strip()
+        parts = [
+            p
+            for p in [binding, f'tenant={iface.tenant}' if iface.tenant else '']
+            if p
+        ]
+        suffix = f'  ({", ".join(parts)})' if parts else ''
+        line = f'  [{i}] {iface.url}{suffix}'
+        lines.append(line)
+
+    lines += [
+        '',
+        '--- Capabilities ---',
+        f'Streaming           : {card.capabilities.streaming}',
+        f'Push notifications  : {card.capabilities.push_notifications}',
+        f'Extended agent card : {card.capabilities.extended_agent_card}',
+    ]
+
+    lines += [
+        '',
+        '--- I/O Modes ---',
+        f'Input  : {", ".join(card.default_input_modes) or "(none)"}',
+        f'Output : {", ".join(card.default_output_modes) or "(none)"}',
+    ]
+
+    lines += ['', '--- Skills ---']
+    if card.skills:
+        for skill in card.skills:
+            lines += [
+                thin,
+                f'  ID          : {skill.id}',
+                f'  Name        : {skill.name}',
+                f'  Description : {skill.description}',
+                f'  Tags        : {", ".join(skill.tags) or "(none)"}',
+            ]
+            if skill.examples:
+                for ex in skill.examples:
+                    lines.append(f'  Example     : {ex}')
+    else:
+        lines.append('  (none)')
+
+    lines.append(sep)
+    print('\n'.join(lines))
diff --git a/src/a2a/helpers/proto_helpers.py b/src/a2a/helpers/proto_helpers.py
new file mode 100644
index 000000000..bcfded761
--- /dev/null
+++ b/src/a2a/helpers/proto_helpers.py
@@ -0,0 +1,641 @@
+"""Unified helper functions for creating and handling A2A types."""
+
+import uuid
+
+from collections.abc import Sequence
+from typing import Any
+
+from google.protobuf import struct_pb2
+from google.protobuf.json_format import MessageToDict, ParseDict
+
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    Message,
+    Part,
+    Role,
+    StreamResponse,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+
+# --- Message Helpers ---
+
+
+def new_message(
+    parts: list[Part],
+    context_id: str | None = None,
+    task_id: str | None = None,
+    role: Role = Role.ROLE_AGENT,
+) -> Message:
+    """Creates a new message containing a list of Parts."""
+    return Message(
+        role=role,
+        parts=parts,
+        message_id=str(uuid.uuid4()),
+        task_id=task_id,
+        context_id=context_id,
+    )
+
+
+def new_text_message(
+    text: str,
+    media_type: str | None = None,
+    context_id: str | None = None,
+    task_id: str | None = None,
+    role: Role = Role.ROLE_AGENT,
+) -> Message:
+    """Creates a new message containing a single text Part."""
+    return new_message(
+        parts=[new_text_part(text, media_type=media_type)],
+        context_id=context_id,
+        task_id=task_id,
+        role=role,
+    )
+
+
+def get_message_text(message: Message, delimiter: str = '\n') -> str:
+    """Extracts and joins all text content from a Message's parts."""
+    return delimiter.join(get_text_parts(message.parts))
+
+
+def new_data_message(
+    data: Any,
+    media_type: str | None = None,
+    context_id: str | None = None,
+    task_id: str | None = None,
+    role: Role = Role.ROLE_AGENT,
+) -> Message:
+    """Creates a new message containing a single data Part.
+
+    Args:
+        data: JSON-serializable data to embed (dict, list, str, etc.).
+        media_type: Optional MIME type of the part content (e.g., "text/plain", "application/json", "image/png").
+        context_id: Optional context ID.
+        task_id: Optional task ID.
+        role: The role of the message sender (default: ROLE_AGENT).
+
+    Returns:
+        A Message with a single data Part.
+    """
+    return new_message(
+        parts=[new_data_part(data, media_type=media_type)],
+        context_id=context_id,
+        task_id=task_id,
+        role=role,
+    )
+
+
+def new_raw_message(  # noqa: PLR0913
+    raw: bytes,
+    media_type: str | None = None,
+    filename: str | None = None,
+    context_id: str | None = None,
+    task_id: str | None = None,
+    role: Role = Role.ROLE_AGENT,
+) -> Message:
+    """Creates a new message containing a single raw bytes Part.
+
+    Args:
+        raw: The raw bytes content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        context_id: Optional context ID.
+        task_id: Optional task ID.
+        role: The role of the message sender (default: ROLE_AGENT).
+
+    Returns:
+        A Message with a single raw Part.
+    """
+    return new_message(
+        parts=[new_raw_part(raw, media_type=media_type, filename=filename)],
+        context_id=context_id,
+        task_id=task_id,
+        role=role,
+    )
+
+
+def new_url_message(  # noqa: PLR0913
+    url: str,
+    media_type: str | None = None,
+    filename: str | None = None,
+    context_id: str | None = None,
+    task_id: str | None = None,
+    role: Role = Role.ROLE_AGENT,
+) -> Message:
+    """Creates a new message containing a single URL Part.
+
+    Args:
+        url: The URL pointing to the file content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        context_id: Optional context ID.
+        task_id: Optional task ID.
+        role: The role of the message sender (default: ROLE_AGENT).
+
+    Returns:
+        A Message with a single URL Part.
+    """
+    return new_message(
+        parts=[new_url_part(url, media_type=media_type, filename=filename)],
+        context_id=context_id,
+        task_id=task_id,
+        role=role,
+    )
+
+
+# --- Artifact Helpers ---
+
+
+def new_artifact(
+    parts: list[Part],
+    name: str,
+    description: str | None = None,
+    artifact_id: str | None = None,
+) -> Artifact:
+    """Creates a new Artifact object."""
+    return Artifact(
+        artifact_id=artifact_id or str(uuid.uuid4()),
+        parts=parts,
+        name=name,
+        description=description,
+    )
+
+
+def new_text_artifact(
+    name: str,
+    text: str,
+    media_type: str | None = None,
+    description: str | None = None,
+    artifact_id: str | None = None,
+) -> Artifact:
+    """Creates a new Artifact object containing only a single text Part."""
+    return new_artifact(
+        [new_text_part(text, media_type=media_type)],
+        name,
+        description,
+        artifact_id=artifact_id,
+    )
+
+
+def new_data_artifact(
+    name: str,
+    data: Any,
+    media_type: str | None = None,
+    description: str | None = None,
+    artifact_id: str | None = None,
+) -> Artifact:
+    """Creates a new Artifact object containing only a single data Part.
+
+    Args:
+        name: The name of the artifact.
+        data: JSON-serializable data to embed (dict, list, str, etc.).
+        media_type: Optional MIME type of the part content (e.g., "text/plain", "application/json", "image/png").
+        description: Optional description.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        An Artifact with a single data Part.
+    """
+    return new_artifact(
+        [new_data_part(data, media_type=media_type)],
+        name,
+        description,
+        artifact_id=artifact_id,
+    )
+
+
+def new_raw_artifact(  # noqa: PLR0913
+    name: str,
+    raw: bytes,
+    media_type: str | None = None,
+    filename: str | None = None,
+    description: str | None = None,
+    artifact_id: str | None = None,
+) -> Artifact:
+    """Creates a new Artifact object containing only a single raw bytes Part.
+
+    Args:
+        name: The name of the artifact.
+        raw: The raw bytes content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        description: Optional description.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        An Artifact with a single raw Part.
+    """
+    return new_artifact(
+        [new_raw_part(raw, media_type=media_type, filename=filename)],
+        name,
+        description,
+        artifact_id=artifact_id,
+    )
+
+
+def new_url_artifact(  # noqa: PLR0913
+    name: str,
+    url: str,
+    media_type: str | None = None,
+    filename: str | None = None,
+    description: str | None = None,
+    artifact_id: str | None = None,
+) -> Artifact:
+    """Creates a new Artifact object containing only a single URL Part.
+
+    Args:
+        name: The name of the artifact.
+        url: The URL pointing to the file content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        description: Optional description.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        An Artifact with a single URL Part.
+    """
+    return new_artifact(
+        [new_url_part(url, media_type=media_type, filename=filename)],
+        name,
+        description,
+        artifact_id=artifact_id,
+    )
+
+
+def get_artifact_text(artifact: Artifact, delimiter: str = '\n') -> str:
+    """Extracts and joins all text content from an Artifact's parts."""
+    return delimiter.join(get_text_parts(artifact.parts))
+
+
+# --- Task Helpers ---
+
+
+def new_task_from_user_message(user_message: Message) -> Task:
+    """Creates a new Task object from an initial user message."""
+    if user_message.role != Role.ROLE_USER:
+        raise ValueError('Message must be from a user')
+    if not user_message.parts:
+        raise ValueError('Message parts cannot be empty')
+    for part in user_message.parts:
+        if part.HasField('text') and not part.text:
+            raise ValueError('Message.text cannot be empty')
+
+    return Task(
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+        id=user_message.task_id or str(uuid.uuid4()),
+        context_id=user_message.context_id or str(uuid.uuid4()),
+        history=[user_message],
+    )
+
+
+def new_task(
+    task_id: str,
+    context_id: str,
+    state: TaskState,
+    artifacts: list[Artifact] | None = None,
+    history: list[Message] | None = None,
+) -> Task:
+    """Creates a Task object with a specified status."""
+    if history is None:
+        history = []
+    if artifacts is None:
+        artifacts = []
+
+    return Task(
+        status=TaskStatus(state=state),
+        id=task_id,
+        context_id=context_id,
+        artifacts=artifacts,
+        history=history,
+    )
+
+
+# --- Part Helpers ---
+
+
+def new_text_part(
+    text: str,
+    media_type: str | None = None,
+) -> Part:
+    """Creates a Part with text content.
+
+    Args:
+        text: The text content.
+        media_type: Optional MIME type (e.g. 'text/plain', 'text/markdown').
+
+    Returns:
+        A Part with the text field set.
+    """
+    return Part(text=text, media_type=media_type or '')
+
+
+def new_data_part(
+    data: Any,
+    media_type: str | None = None,
+) -> Part:
+    """Creates a Part with structured data (google.protobuf.Value).
+
+    Note:
+        ``google.protobuf.Value`` stores every number as a double, so whole
+        numbers lose their integer type here and are read back as floats
+        (``4326`` becomes ``4326.0``). See ``get_data_parts``.
+
+    Args:
+        data: JSON-serializable data to embed (dict, list, str, etc.).
+        media_type: Optional MIME type of the part content (e.g., "text/plain", "application/json", "image/png").
+
+    Returns:
+        A Part with the data field set.
+    """
+    return Part(
+        data=ParseDict(data, struct_pb2.Value()),
+        media_type=media_type or '',
+    )
+
+
+def new_raw_part(
+    raw: bytes,
+    media_type: str | None = None,
+    filename: str | None = None,
+) -> Part:
+    """Creates a Part with raw bytes content.
+
+    Args:
+        raw: The raw bytes content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+
+    Returns:
+        A Part with the raw field set.
+    """
+    return Part(
+        raw=raw,
+        media_type=media_type or '',
+        filename=filename or '',
+    )
+
+
+def new_url_part(
+    url: str,
+    media_type: str | None = None,
+    filename: str | None = None,
+) -> Part:
+    """Creates a Part with a URL pointing to file content.
+
+    Args:
+        url: The URL to the file content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+
+    Returns:
+        A Part with the url field set.
+    """
+    return Part(
+        url=url,
+        media_type=media_type or '',
+        filename=filename or '',
+    )
+
+
+def get_text_parts(parts: Sequence[Part]) -> list[str]:
+    """Extracts text content from all text Parts."""
+    return [part.text for part in parts if part.HasField('text')]
+
+
+def get_data_parts(parts: Sequence[Part]) -> list[Any]:
+    """Extracts structured data from all data Parts.
+
+    Each returned element is the Python object obtained by converting
+    the ``google.protobuf.Value`` back via ``MessageToDict``.
+
+    Note:
+        Whole numbers come back as floats (``4326`` becomes ``4326.0``)
+        because ``google.protobuf.Value`` stores numbers as doubles. For
+        fields you model as integers, narrow floats with ``is_integer()``.
+
+    Args:
+        parts: A sequence of ``Part`` objects.
+
+    Returns:
+        A list of deserialized Python objects from any data Parts found.
+    """
+    return [MessageToDict(part.data) for part in parts if part.HasField('data')]
+
+
+def get_raw_parts(parts: Sequence[Part]) -> list[bytes]:
+    """Extracts raw bytes content from all raw Parts.
+
+    Args:
+        parts: A sequence of ``Part`` objects.
+
+    Returns:
+        A list of ``bytes`` from any raw Parts found.
+    """
+    return [part.raw for part in parts if part.HasField('raw')]
+
+
+def get_url_parts(parts: Sequence[Part]) -> list[str]:
+    """Extracts URL strings from all URL Parts.
+
+    Args:
+        parts: A sequence of ``Part`` objects.
+
+    Returns:
+        A list of URL strings from any URL Parts found.
+    """
+    return [part.url for part in parts if part.HasField('url')]
+
+
+# --- Event & Stream Helpers ---
+
+
+def new_text_status_update_event(
+    task_id: str,
+    context_id: str,
+    state: TaskState,
+    text: str,
+) -> TaskStatusUpdateEvent:
+    """Creates a TaskStatusUpdateEvent with a single text message."""
+    return TaskStatusUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        status=TaskStatus(
+            state=state,
+            message=new_text_message(
+                text=text,
+                role=Role.ROLE_AGENT,
+                context_id=context_id,
+                task_id=task_id,
+            ),
+        ),
+    )
+
+
+def new_text_artifact_update_event(  # noqa: PLR0913
+    task_id: str,
+    context_id: str,
+    name: str,
+    text: str,
+    append: bool = False,
+    last_chunk: bool = False,
+    artifact_id: str | None = None,
+) -> TaskArtifactUpdateEvent:
+    """Creates a TaskArtifactUpdateEvent with a single text artifact."""
+    return TaskArtifactUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        artifact=new_text_artifact(
+            name=name, text=text, artifact_id=artifact_id
+        ),
+        append=append,
+        last_chunk=last_chunk,
+    )
+
+
+def new_data_artifact_update_event(  # noqa: PLR0913
+    task_id: str,
+    context_id: str,
+    name: str,
+    data: Any,
+    media_type: str | None = None,
+    append: bool = False,
+    last_chunk: bool = False,
+    artifact_id: str | None = None,
+) -> TaskArtifactUpdateEvent:
+    """Creates a TaskArtifactUpdateEvent with a single data artifact.
+
+    Args:
+        task_id: The task ID.
+        context_id: The context ID.
+        name: The name of the artifact.
+        data: JSON-serializable data to embed (dict, list, str, etc.).
+        media_type: Optional MIME type of the part content.
+        append: Whether to append to the existing artifact.
+        last_chunk: Whether this is the last chunk.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        A TaskArtifactUpdateEvent with a single data artifact.
+    """
+    return TaskArtifactUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        artifact=new_data_artifact(
+            name=name,
+            data=data,
+            media_type=media_type,
+            artifact_id=artifact_id,
+        ),
+        append=append,
+        last_chunk=last_chunk,
+    )
+
+
+def new_raw_artifact_update_event(  # noqa: PLR0913
+    task_id: str,
+    context_id: str,
+    name: str,
+    raw: bytes,
+    media_type: str | None = None,
+    filename: str | None = None,
+    append: bool = False,
+    last_chunk: bool = False,
+    artifact_id: str | None = None,
+) -> TaskArtifactUpdateEvent:
+    """Creates a TaskArtifactUpdateEvent with a single raw bytes artifact.
+
+    Args:
+        task_id: The task ID.
+        context_id: The context ID.
+        name: The name of the artifact.
+        raw: The raw bytes content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        append: Whether to append to the existing artifact.
+        last_chunk: Whether this is the last chunk.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        A TaskArtifactUpdateEvent with a single raw artifact.
+    """
+    return TaskArtifactUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        artifact=new_raw_artifact(
+            name=name,
+            raw=raw,
+            media_type=media_type,
+            filename=filename,
+            artifact_id=artifact_id,
+        ),
+        append=append,
+        last_chunk=last_chunk,
+    )
+
+
+def new_url_artifact_update_event(  # noqa: PLR0913
+    task_id: str,
+    context_id: str,
+    name: str,
+    url: str,
+    media_type: str | None = None,
+    filename: str | None = None,
+    append: bool = False,
+    last_chunk: bool = False,
+    artifact_id: str | None = None,
+) -> TaskArtifactUpdateEvent:
+    """Creates a TaskArtifactUpdateEvent with a single URL artifact.
+
+    Args:
+        task_id: The task ID.
+        context_id: The context ID.
+        name: The name of the artifact.
+        url: The URL pointing to the file content.
+        media_type: Optional MIME type (e.g. 'image/png').
+        filename: Optional filename.
+        append: Whether to append to the existing artifact.
+        last_chunk: Whether this is the last chunk.
+        artifact_id: Optional artifact ID (auto-generated if not provided).
+
+    Returns:
+        A TaskArtifactUpdateEvent with a single URL artifact.
+    """
+    return TaskArtifactUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        artifact=new_url_artifact(
+            name=name,
+            url=url,
+            media_type=media_type,
+            filename=filename,
+            artifact_id=artifact_id,
+        ),
+        append=append,
+        last_chunk=last_chunk,
+    )
+
+
+def get_stream_response_text(
+    response: StreamResponse, delimiter: str = '\n'
+) -> str:
+    """Extracts text content from a StreamResponse."""
+    if response.HasField('message'):
+        return get_message_text(response.message, delimiter)
+    if response.HasField('task'):
+        texts = [
+            get_artifact_text(a, delimiter) for a in response.task.artifacts
+        ]
+        return delimiter.join(t for t in texts if t)
+    if response.HasField('status_update'):
+        if response.status_update.status.HasField('message'):
+            return get_message_text(
+                response.status_update.status.message, delimiter
+            )
+        return ''
+    if response.HasField('artifact_update'):
+        return get_artifact_text(response.artifact_update.artifact, delimiter)
+    return ''
diff --git a/src/a2a/migrations/README.md b/src/a2a/migrations/README.md
new file mode 100644
index 000000000..4767363ff
--- /dev/null
+++ b/src/a2a/migrations/README.md
@@ -0,0 +1,125 @@
+# A2A SDK Database Migrations
+
+This directory handles the database schema updates for the A2A SDK. It uses a bundled CLI tool to simplify the migration process.
+
+## Installation
+
+To use the `a2a-db` migration tool, install the `a2a-sdk` with the `db-cli` extra.
+
+| Extra | `uv` Command | `pip` Command |
+| :--- | :--- | :--- |
+| **CLI Only** | `uv add "a2a-sdk[db-cli]"` | `pip install "a2a-sdk[db-cli]"` |
+| **All Extras** | `uv add "a2a-sdk[all]"` | `pip install "a2a-sdk[all]"` |
+
+
+## User Guide for Integrators
+
+When you install the `a2a-sdk`, you get a built-in command `a2a-db` which updates your database to make it compatible with the latest version of the SDK.
+
+### 1. Recommended: Back up your database
+
+Before running migrations, it is recommended to back up your database.
+
+### 2. Set your Database URL
+Migrations require the `DATABASE_URL` environment variable to be set with an `async-compatible` driver. 
+You can set it globally with `export DATABASE_URL`. Examples for SQLite, PostgreSQL and MySQL, respectively:
+
+```bash
+export DATABASE_URL="sqlite+aiosqlite://user:pass@host:port/your_database_name"
+
+export DATABASE_URL="postgresql+asyncpg://user:pass@localhost/your_database_name"
+
+export DATABASE_URL="mysql+aiomysql://user:pass@localhost/your_database_name"
+```
+
+Or you can use the `--database-url` flag to specify the database URL for a single command.
+
+
+### 3. Apply Migrations
+Always run this command after installing or upgrading the SDK to ensure your database matches the required schema. This will upgrade the tables `tasks` and `push_notification_configs` in your database by adding columns `owner` and `last_updated` and an index `(owner, last_updated)` to the `tasks` table and a column `owner` to the `push_notification_configs` table.
+
+Revision `b5e3d1c8a2f7` creates two additive tables, `task_versions` and `task_events`, used only by the clustered multi-server stores (`a2a.server.cluster`). It leaves the `tasks` table untouched, so deployments that use the default `DatabaseTaskStore` need not run it and are unaffected. Run it only when adopting a `VersionedTaskStore` for multi-server deployment.
+
+```bash
+uv run a2a-db
+```
+
+### 4. Customizing Defaults with Flags
+#### --add_columns_owner_last_updated-default-owner
+Allows you to pass custom values for the new `owner` column. If not set, it will default to the value `legacy_v03_no_user_info`.
+
+```bash
+uv run a2a-db --add_columns_owner_last_updated-default-owner "admin_user"
+```
+#### --database-url
+You can use the `--database-url` flag to specify the database URL for a single command.
+
+```bash
+uv run a2a-db --database-url "sqlite+aiosqlite:///my_database.db"
+```
+#### --tasks-table / --push-notification-configs-table
+Custom tasks and push notification configs tables to update. If not set, the default are `tasks` and `push_notification_configs`.
+
+```bash
+uv run a2a-db --tasks-table "my_tasks" --push-notification-configs-table "my_configs"
+```
+#### -v / --verbose
+Enables verbose output by setting `sqlalchemy.engine` logging to `INFO`.
+
+```bash
+uv run a2a-db -v
+```
+#### --sql
+Enables running migrations in `offline` mode. Migrations are generated as SQL scripts and printed to stdout instead of being run against the database.
+
+```bash
+uv run a2a-db --sql
+```
+
+### 5. Rolling Back
+If you need to revert a change:
+
+```bash
+# Step back one version
+uv run a2a-db downgrade -1
+
+# Downgrade to a specific revision ID
+uv run a2a-db downgrade <revision_id>
+
+# Revert all migrations
+uv run a2a-db downgrade base
+
+# Revert all migrations in offline mode
+uv run a2a-db downgrade head:base --sql
+```
+
+> [!NOTE]
+> All flags except `--add_columns_owner_last_updated-default-owner` can be used during rollbacks.
+
+### 6. Verifying Current Status
+To see the current revision applied to your database:
+
+```bash
+uv run a2a-db current
+
+# To see more details (like revision dates, if available)
+uv run a2a-db current -v
+```
+---
+
+## Developer Guide for SDK Contributors
+
+If you are modifying the SDK models and need to generate new migration files, use the following workflow.
+
+### Creating a New Migration
+Developers should use the raw `alembic` command locally to generate migrations. Ensure you are in the project root.
+
+```bash
+# Detect changes in models.py and generate a script
+uv run alembic revision --autogenerate -m "description of changes"
+```
+
+### Internal Layout
+- `env.py`: Configures the migration engine and applies the mandatory `DATABASE_URL` check.
+- `versions/`: Contains the migration history.
+- `script.py.mako`: The template for all new migration files.
diff --git a/src/a2a/migrations/__init__.py b/src/a2a/migrations/__init__.py
new file mode 100644
index 000000000..7b55fb93e
--- /dev/null
+++ b/src/a2a/migrations/__init__.py
@@ -0,0 +1 @@
+"Alembic database migration package."
diff --git a/src/a2a/migrations/env.py b/src/a2a/migrations/env.py
new file mode 100644
index 000000000..448d39e87
--- /dev/null
+++ b/src/a2a/migrations/env.py
@@ -0,0 +1,127 @@
+import asyncio
+import logging
+import os
+
+from logging.config import fileConfig
+
+from sqlalchemy import Connection, pool
+from sqlalchemy.ext.asyncio import async_engine_from_config
+
+from a2a.server.models import Base
+
+try:
+    from alembic import context
+except ImportError as e:
+    raise ImportError(
+        "Migrations require Alembic. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Mandatory database configuration
+db_url = os.getenv('DATABASE_URL')
+if not db_url:
+    raise RuntimeError(
+        'DATABASE_URL environment variable is not set. '
+        "Please set it (e.g., export DATABASE_URL='sqlite+aiosqlite:///./my-database.db') before running migrations "
+        'or use the --database-url flag.'
+    )
+config.set_main_option('sqlalchemy.url', db_url)
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if (
+    config.config_file_name is not None
+    and os.path.exists(config.config_file_name)
+    and config.config_file_name.endswith('.ini')
+):
+    fileConfig(config.config_file_name)
+
+if config.get_main_option('verbose') == 'true':
+    logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
+
+# add your model's MetaData object here for 'autogenerate' support
+target_metadata = Base.metadata
+
+# Version table name to avoid conflicts with existing alembic_version tables in the database.
+# This ensures that the migration history for A2A is tracked separately.
+VERSION_TABLE = 'a2a_alembic_version'
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option('sqlalchemy.url')
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={'paramstyle': 'named'},
+        version_table=VERSION_TABLE,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection: Connection) -> None:
+    """Run migrations in 'online' mode.
+
+    This function is called within a synchronous context (via run_sync)
+    to configure the migration context with the provided connection
+    and target metadata, then execute the migrations within a transaction.
+
+    Args:
+        connection: The SQLAlchemy connection to use for the migrations.
+    """
+    context.configure(
+        connection=connection,
+        target_metadata=target_metadata,
+        version_table=VERSION_TABLE,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_async_migrations() -> None:
+    """Run migrations using an Engine.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+    """
+    connectable = async_engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    asyncio.run(run_async_migrations())
+
+
+if context.is_offline_mode():
+    logging.info('Running migrations in offline mode.')
+    run_migrations_offline()
+else:
+    logging.info('Running migrations in online mode.')
+    run_migrations_online()
diff --git a/src/a2a/migrations/migration_utils.py b/src/a2a/migrations/migration_utils.py
new file mode 100644
index 000000000..4a09ede91
--- /dev/null
+++ b/src/a2a/migrations/migration_utils.py
@@ -0,0 +1,110 @@
+"""Utility functions for Alembic migrations."""
+
+import logging
+from typing import Any
+
+import sqlalchemy as sa
+
+try:
+    from alembic import context, op
+except ImportError as e:
+    raise ImportError(
+        "A2A migrations require the 'db-cli' extra. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+
+def _get_inspector() -> sa.engine.reflection.Inspector:
+    """Get the current database inspector."""
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    return inspector
+
+
+def table_exists(table_name: str) -> bool:
+    """Check if a table exists in the database."""
+    if context.is_offline_mode():
+        return True
+    inspector = _get_inspector()
+    return table_name in inspector.get_table_names()
+
+
+def column_exists(
+    table_name: str, column_name: str, downgrade_mode: bool = False
+) -> bool:
+    """Check if a column exists in a table."""
+    if context.is_offline_mode():
+        return downgrade_mode
+
+    inspector = _get_inspector()
+    columns = [c['name'] for c in inspector.get_columns(table_name)]
+    return column_name in columns
+
+
+def index_exists(
+    table_name: str, index_name: str, downgrade_mode: bool = False
+) -> bool:
+    """Check if an index exists on a table."""
+    if context.is_offline_mode():
+        return downgrade_mode
+
+    inspector = _get_inspector()
+    indexes = [i['name'] for i in inspector.get_indexes(table_name)]
+    return index_name in indexes
+
+
+def add_column(
+    table: str,
+    column_name: str,
+    nullable: bool,
+    type_: sa.types.TypeEngine,
+    default: Any | None = None,
+) -> None:
+    """Add a column to a table if it doesn't already exist."""
+    if not column_exists(table, column_name):
+        op.add_column(
+            table,
+            sa.Column(
+                column_name,
+                type_,
+                nullable=nullable,
+                server_default=default,
+            ),
+        )
+    else:
+        logging.info(
+            f"Column '{column_name}' already exists in table '{table}'. Skipping."
+        )
+
+
+def drop_column(table: str, column_name: str) -> None:
+    """Drop a column from a table if it exists."""
+    if column_exists(table, column_name, True):
+        op.drop_column(table, column_name)
+    else:
+        logging.info(
+            f"Column '{column_name}' does not exist in table '{table}'. Skipping."
+        )
+
+
+def add_index(table: str, index_name: str, columns: list[str]) -> None:
+    """Create an index on a table if it doesn't already exist."""
+    if not index_exists(table, index_name):
+        op.create_index(
+            index_name,
+            table,
+            columns,
+        )
+    else:
+        logging.info(
+            f"Index '{index_name}' already exists on table '{table}'. Skipping."
+        )
+
+
+def drop_index(table: str, index_name: str) -> None:
+    """Drop an index from a table if it exists."""
+    if index_exists(table, index_name, True):
+        op.drop_index(index_name, table_name=table)
+    else:
+        logging.info(
+            f"Index '{index_name}' does not exist on table '{table}'. Skipping."
+        )
diff --git a/src/a2a/migrations/script.py.mako b/src/a2a/migrations/script.py.mako
new file mode 100644
index 000000000..9caa81d6a
--- /dev/null
+++ b/src/a2a/migrations/script.py.mako
@@ -0,0 +1,35 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+try:
+    from alembic import op
+except ImportError as e:
+    raise ImportError(
+        "A2A migrations require the 'db-cli' extra. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}
diff --git a/src/a2a/migrations/versions/38ce57e08137_add_column_protocol_version.py b/src/a2a/migrations/versions/38ce57e08137_add_column_protocol_version.py
new file mode 100644
index 000000000..58948aa8c
--- /dev/null
+++ b/src/a2a/migrations/versions/38ce57e08137_add_column_protocol_version.py
@@ -0,0 +1,78 @@
+"""add column protocol version
+
+Revision ID: 38ce57e08137
+Revises: 6419d2d130f6
+Create Date: 2026-03-09 12:07:16.998955
+
+"""
+
+import logging
+from collections.abc import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+
+try:
+    from alembic import context
+except ImportError as e:
+    raise ImportError(
+        "A2A migrations require the 'db-cli' extra. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+from a2a.migrations.migration_utils import table_exists, add_column, drop_column
+
+
+# revision identifiers, used by Alembic.
+revision: str = '38ce57e08137'
+down_revision: Union[str, Sequence[str], None] = '6419d2d130f6'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    tasks_table = context.config.get_main_option('tasks_table', 'tasks')
+    push_notification_configs_table = context.config.get_main_option(
+        'push_notification_configs_table', 'push_notification_configs'
+    )
+
+    if table_exists(tasks_table):
+        add_column(tasks_table, 'protocol_version', True, sa.String(16))
+    else:
+        logging.warning(
+            f"Table '{tasks_table}' does not exist. Skipping upgrade for this table."
+        )
+
+    if table_exists(push_notification_configs_table):
+        add_column(
+            push_notification_configs_table,
+            'protocol_version',
+            True,
+            sa.String(16),
+        )
+    else:
+        logging.warning(
+            f"Table '{push_notification_configs_table}' does not exist. Skipping upgrade for this table."
+        )
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    tasks_table = context.config.get_main_option('tasks_table', 'tasks')
+    push_notification_configs_table = context.config.get_main_option(
+        'push_notification_configs_table', 'push_notification_configs'
+    )
+
+    if table_exists(tasks_table):
+        drop_column(tasks_table, 'protocol_version')
+    else:
+        logging.warning(
+            f"Table '{tasks_table}' does not exist. Skipping downgrade for this table."
+        )
+
+    if table_exists(push_notification_configs_table):
+        drop_column(push_notification_configs_table, 'protocol_version')
+    else:
+        logging.warning(
+            f"Table '{push_notification_configs_table}' does not exist. Skipping downgrade for this table."
+        )
diff --git a/src/a2a/migrations/versions/6419d2d130f6_add_columns_owner_last_updated.py b/src/a2a/migrations/versions/6419d2d130f6_add_columns_owner_last_updated.py
new file mode 100644
index 000000000..fc0f1097e
--- /dev/null
+++ b/src/a2a/migrations/versions/6419d2d130f6_add_columns_owner_last_updated.py
@@ -0,0 +1,109 @@
+"""add_columns_owner_last_updated.
+
+Revision ID: 6419d2d130f6
+Revises:
+Create Date: 2026-02-17 09:23:06.758085
+
+"""
+
+import logging
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+try:
+    from alembic import context
+except ImportError as e:
+    raise ImportError(
+        "'Add columns owner and last_updated to database tables' migration requires Alembic. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+from a2a.migrations.migration_utils import (
+    table_exists,
+    add_column,
+    add_index,
+    drop_column,
+    drop_index,
+)
+
+
+# revision identifiers, used by Alembic.
+revision: str = '6419d2d130f6'
+down_revision: str | Sequence[str] | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # Get the default value from the config (passed via CLI)
+    owner = context.config.get_main_option(
+        'add_columns_owner_last_updated_default_owner',
+        'legacy_v03_no_user_info',
+    )
+    tasks_table = context.config.get_main_option('tasks_table', 'tasks')
+    push_notification_configs_table = context.config.get_main_option(
+        'push_notification_configs_table', 'push_notification_configs'
+    )
+
+    if table_exists(tasks_table):
+        add_column(tasks_table, 'owner', True, sa.String(255), owner)
+        add_column(tasks_table, 'last_updated', True, sa.DateTime())
+        add_index(
+            tasks_table,
+            f'idx_{tasks_table}_owner_last_updated',
+            ['owner', 'last_updated'],
+        )
+    else:
+        logging.warning(
+            f"Table '{tasks_table}' does not exist. Skipping upgrade for this table."
+        )
+
+    if table_exists(push_notification_configs_table):
+        add_column(
+            push_notification_configs_table,
+            'owner',
+            True,
+            sa.String(255),
+            owner,
+        )
+        add_index(
+            push_notification_configs_table,
+            f'ix_{push_notification_configs_table}_owner',
+            ['owner'],
+        )
+    else:
+        logging.warning(
+            f"Table '{push_notification_configs_table}' does not exist. Skipping upgrade for this table."
+        )
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    tasks_table = context.config.get_main_option('tasks_table', 'tasks')
+    push_notification_configs_table = context.config.get_main_option(
+        'push_notification_configs_table', 'push_notification_configs'
+    )
+
+    if table_exists(tasks_table):
+        drop_index(
+            tasks_table,
+            f'idx_{tasks_table}_owner_last_updated',
+        )
+        drop_column(tasks_table, 'owner')
+        drop_column(tasks_table, 'last_updated')
+    else:
+        logging.warning(
+            f"Table '{tasks_table}' does not exist. Skipping downgrade for this table."
+        )
+
+    if table_exists(push_notification_configs_table):
+        drop_index(
+            push_notification_configs_table,
+            f'ix_{push_notification_configs_table}_owner',
+        )
+        drop_column(push_notification_configs_table, 'owner')
+    else:
+        logging.warning(
+            f"Table '{push_notification_configs_table}' does not exist. Skipping downgrade for this table."
+        )
diff --git a/src/a2a/migrations/versions/__init__.py b/src/a2a/migrations/versions/__init__.py
new file mode 100644
index 000000000..574828c67
--- /dev/null
+++ b/src/a2a/migrations/versions/__init__.py
@@ -0,0 +1 @@
+"""Alembic migrations scripts for the A2A project."""
diff --git a/src/a2a/migrations/versions/b5e3d1c8a2f7_add_task_version_and_task_events.py b/src/a2a/migrations/versions/b5e3d1c8a2f7_add_task_version_and_task_events.py
new file mode 100644
index 000000000..9d03ad033
--- /dev/null
+++ b/src/a2a/migrations/versions/b5e3d1c8a2f7_add_task_version_and_task_events.py
@@ -0,0 +1,100 @@
+"""add task_versions and task_events tables
+
+Revision ID: b5e3d1c8a2f7
+Revises: 38ce57e08137
+Create Date: 2026-09-14 10:00:00.000000
+
+"""
+
+import logging
+
+from collections.abc import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+
+
+try:
+    from alembic import context, op
+except ImportError as e:
+    raise ImportError(
+        "A2A migrations require the 'db-cli' extra. Install with: 'pip install a2a-sdk[db-cli]'."
+    ) from e
+
+from a2a.migrations.migration_utils import table_exists
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'b5e3d1c8a2f7'
+down_revision: Union[str, Sequence[str], None] = '38ce57e08137'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def _seq_type() -> sa.types.TypeEngine:
+    """Primary-key type for the event log.
+
+    BigInteger everywhere except SQLite, whose AUTOINCREMENT requires a plain
+    INTEGER column. Mirrors ``TaskEventMixin.seq`` in a2a.server.models.
+    """
+    return sa.BigInteger().with_variant(sa.Integer(), 'sqlite')
+
+
+def upgrade() -> None:
+    """Upgrade schema: create the task_versions and task_events tables."""
+    versions_table = context.config.get_main_option(
+        'task_versions_table', 'task_versions'
+    )
+    events_table = context.config.get_main_option(
+        'task_events_table', 'task_events'
+    )
+
+    if context.is_offline_mode() or not table_exists(versions_table):
+        op.create_table(
+            versions_table,
+            sa.Column('task_id', sa.String(36), primary_key=True),
+            sa.Column('owner', sa.String(255), nullable=True),
+            sa.Column('version', sa.BigInteger(), nullable=False),
+        )
+    else:
+        logging.info(
+            "Table '%s' already exists. Skipping creation.", versions_table
+        )
+
+    if context.is_offline_mode() or not table_exists(events_table):
+        op.create_table(
+            events_table,
+            sa.Column('seq', _seq_type(), primary_key=True, autoincrement=True),
+            sa.Column('task_id', sa.String(36), nullable=False),
+            sa.Column('owner', sa.String(255), nullable=True),
+            sa.Column('task_version', sa.BigInteger(), nullable=False),
+            sa.Column('event_data', sa.LargeBinary(), nullable=False),
+        )
+        op.create_index(f'ix_{events_table}_task_id', events_table, ['task_id'])
+    else:
+        logging.info(
+            "Table '%s' already exists. Skipping creation.", events_table
+        )
+
+
+def downgrade() -> None:
+    """Downgrade schema: drop the task_events and task_versions tables."""
+    versions_table = context.config.get_main_option(
+        'task_versions_table', 'task_versions'
+    )
+    events_table = context.config.get_main_option(
+        'task_events_table', 'task_events'
+    )
+
+    if context.is_offline_mode() or table_exists(events_table):
+        op.drop_index(f'ix_{events_table}_task_id', table_name=events_table)
+        op.drop_table(events_table)
+    else:
+        logging.info("Table '%s' does not exist. Skipping drop.", events_table)
+
+    if context.is_offline_mode() or table_exists(versions_table):
+        op.drop_table(versions_table)
+    else:
+        logging.info(
+            "Table '%s' does not exist. Skipping drop.", versions_table
+        )
diff --git a/src/a2a/plugins/__init__.py b/src/a2a/plugins/__init__.py
new file mode 100644
index 000000000..e233773a3
--- /dev/null
+++ b/src/a2a/plugins/__init__.py
@@ -0,0 +1,63 @@
+"""Plugins: hooks into the A2A client and `DefaultRequestHandlerV2`.
+
+Example:
+    from a2a import plugins
+
+    class TaskAudit(plugins.TaskObserverPlugin):
+        name = 'task-audit'
+
+        async def on_task_event(self, info: plugins.TaskEventInfo) -> None:
+            print(info.task_id, info.from_state, '->', info.to_state)
+
+    plugins.set_global(plugins.sequential(TaskAudit()))
+    # Create DefaultRequestHandlerV2 and clients after this point.
+"""
+
+from a2a.plugins.base import (
+    ClientPlugin,
+    CompletePlugin,
+    ExecutionPlugin,
+    Plugin,
+    PushPlugin,
+    ServerPlugin,
+    TaskObserverPlugin,
+)
+from a2a.plugins.manager import (
+    PluginManager,
+    SequentialPluginManager,
+    get_global,
+    sequential,
+    set_global,
+)
+from a2a.plugins.types import (
+    ClientRequest,
+    ClientResponse,
+    PushRequest,
+    PushResult,
+    ServerRequest,
+    ServerResponse,
+    TaskEventInfo,
+)
+
+
+__all__ = [
+    'ClientPlugin',
+    'ClientRequest',
+    'ClientResponse',
+    'CompletePlugin',
+    'ExecutionPlugin',
+    'Plugin',
+    'PluginManager',
+    'PushPlugin',
+    'PushRequest',
+    'PushResult',
+    'SequentialPluginManager',
+    'ServerPlugin',
+    'ServerRequest',
+    'ServerResponse',
+    'TaskEventInfo',
+    'TaskObserverPlugin',
+    'get_global',
+    'sequential',
+    'set_global',
+]
diff --git a/src/a2a/plugins/base.py b/src/a2a/plugins/base.py
new file mode 100644
index 000000000..23a51eb53
--- /dev/null
+++ b/src/a2a/plugins/base.py
@@ -0,0 +1,104 @@
+"""Plugin interfaces.
+
+A plugin inherits from the interfaces it needs and overrides only the hooks
+it uses; every base method is a no-op.
+
+Interceptor hooks (``before_*``) may modify their argument or reject the call
+by raising. Exceptions from ``after_*`` and observer hooks (``on_*``) are
+logged and swallowed by the plugin manager.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from a2a.plugins.types import (
+        ClientRequest,
+        ClientResponse,
+        PushRequest,
+        PushResult,
+        ServerRequest,
+        ServerResponse,
+        TaskEventInfo,
+    )
+    from a2a.server.agent_execution.context import RequestContext
+    from a2a.server.events.event_queue import Event
+
+
+class Plugin:
+    """Common base of all plugins."""
+
+    name: str = 'unnamed'
+    """Name used in logs."""
+
+
+class ServerPlugin(Plugin):
+    """Hooks around each request handled by `DefaultRequestHandlerV2`."""
+
+    async def before_handler_run(self, request: ServerRequest) -> None:
+        """Called before the handler processes a request.
+
+        Raise to reject the request; the exception is returned to the caller.
+        """
+
+    async def after_handler_run(self, response: ServerResponse) -> None:
+        """Called with the handler result, per stream event, and at the end."""
+
+
+class ClientPlugin(Plugin):
+    """Hooks around each request made by an A2A `Client`."""
+
+    async def before_client_request(self, request: ClientRequest) -> None:
+        """Called before the request is sent. Raise to cancel it."""
+
+    async def after_client_request(self, response: ClientResponse) -> None:
+        """Called with the result, per stream event, and at the end."""
+
+
+class ExecutionPlugin(Plugin):
+    """Hooks around `AgentExecutor.execute`, which runs outside the request."""
+
+    async def before_execution(self, request_context: RequestContext) -> None:
+        """Called in the execution task before the agent runs.
+
+        Raise to fail the execution without running the agent.
+        """
+
+    async def on_execution_event(
+        self, request_context: RequestContext, event: Event
+    ) -> None:
+        """Called when the agent enqueues an event, before it is processed.
+
+        Observer: runs on the agent's path, so keep it cheap.
+        """
+
+    async def after_execution(
+        self, request_context: RequestContext, error: BaseException | None
+    ) -> None:
+        """Called in the execution task after the agent returns or raises."""
+
+
+class TaskObserverPlugin(Plugin):
+    """Observer of task writes."""
+
+    async def on_task_event(self, info: TaskEventInfo) -> None:
+        """Called after every successful task write."""
+
+
+class PushPlugin(Plugin):
+    """Hooks around each push notification delivery."""
+
+    async def before_push_send(self, request: PushRequest) -> None:
+        """Called before the webhook request.
+
+        May add headers or set ``request.skip``. Raising fails the delivery.
+        """
+
+    async def on_push_sent(self, result: PushResult) -> None:
+        """Called after the delivery attempt, or when it was skipped."""
+
+
+class CompletePlugin(ClientPlugin, ServerPlugin):
+    """A plugin with both client and server hooks."""
diff --git a/src/a2a/plugins/manager.py b/src/a2a/plugins/manager.py
new file mode 100644
index 000000000..0b2af80d9
--- /dev/null
+++ b/src/a2a/plugins/manager.py
@@ -0,0 +1,296 @@
+"""Plugin managers and the global registry."""
+
+from __future__ import annotations
+
+import logging
+
+from typing import TYPE_CHECKING, TypeVar
+
+from a2a.plugins.base import (
+    ClientPlugin,
+    ExecutionPlugin,
+    Plugin,
+    PushPlugin,
+    ServerPlugin,
+    TaskObserverPlugin,
+)
+from a2a.plugins.types import ClientResponse, ServerResponse
+
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
+    from a2a.plugins.types import (
+        ClientRequest,
+        PushRequest,
+        PushResult,
+        ServerRequest,
+        TaskEventInfo,
+    )
+    from a2a.server.agent_execution.context import RequestContext
+    from a2a.server.events.event_queue import Event
+
+
+logger = logging.getLogger(__name__)
+
+
+async def _run_safely(plugin: Plugin, hook: str, call: Awaitable[None]) -> None:
+    """Awaits a hook call, logging and swallowing any exception."""
+    try:
+        await call
+    except Exception:
+        logger.exception('A2A plugin %r failed in %s', plugin.name, hook)
+
+
+class PluginManager(
+    ServerPlugin, ClientPlugin, ExecutionPlugin, TaskObserverPlugin, PushPlugin
+):
+    """Runs registered plugins. SDK call sites depend on this type.
+
+    Since a manager implements every plugin interface, managers can be nested.
+    The ``has_*`` properties let call sites skip all plugin work when no
+    plugin implements the hooks they would call.
+    """
+
+    name = 'plugin-manager'
+
+    @property
+    def has_server_hooks(self) -> bool:
+        """Whether any plugin implements `ServerPlugin`."""
+        return False
+
+    @property
+    def has_client_hooks(self) -> bool:
+        """Whether any plugin implements `ClientPlugin`."""
+        return False
+
+    @property
+    def has_execution_hooks(self) -> bool:
+        """Whether any plugin implements `ExecutionPlugin`."""
+        return False
+
+    @property
+    def has_task_hooks(self) -> bool:
+        """Whether any plugin implements `TaskObserverPlugin`."""
+        return False
+
+    @property
+    def has_push_hooks(self) -> bool:
+        """Whether any plugin implements `PushPlugin`."""
+        return False
+
+
+_P = TypeVar('_P', bound=Plugin)
+
+
+def _select(
+    plugins: tuple[Plugin, ...], kind: type[_P], has_hooks: str
+) -> list[_P]:
+    """Returns plugins implementing ``kind``; nested managers only if non-empty."""
+    return [
+        p
+        for p in plugins
+        if isinstance(p, kind)
+        and (not isinstance(p, PluginManager) or getattr(p, has_hooks))
+    ]
+
+
+class SequentialPluginManager(PluginManager):
+    """Runs plugins one after another in registration order.
+
+    - ``before_*`` hooks run in registration order. If one raises, plugins
+      that already ran get their ``after_*`` hook with the error, and the
+      exception propagates.
+    - ``after_*`` hooks run in reverse order. Their exceptions are logged and
+      swallowed.
+    - Observer hooks (``on_*``) run in registration order. Their exceptions
+      are logged and swallowed.
+    """
+
+    name = 'sequential'
+
+    def __init__(self, *plugins: Plugin):
+        unknown = [p for p in plugins if not isinstance(p, Plugin)]
+        if unknown:
+            raise TypeError(f'Not A2A plugins: {unknown!r}')
+        self._plugins = plugins
+        self._server: list[ServerPlugin] = _select(
+            plugins, ServerPlugin, 'has_server_hooks'
+        )
+        self._client: list[ClientPlugin] = _select(
+            plugins, ClientPlugin, 'has_client_hooks'
+        )
+        self._execution: list[ExecutionPlugin] = _select(
+            plugins, ExecutionPlugin, 'has_execution_hooks'
+        )
+        self._task: list[TaskObserverPlugin] = _select(
+            plugins, TaskObserverPlugin, 'has_task_hooks'
+        )
+        self._push: list[PushPlugin] = _select(
+            plugins, PushPlugin, 'has_push_hooks'
+        )
+
+    @property
+    def plugins(self) -> tuple[Plugin, ...]:
+        """The registered plugins, in registration order."""
+        return self._plugins
+
+    @property
+    def has_server_hooks(self) -> bool:  # noqa: D102
+        return bool(self._server)
+
+    @property
+    def has_client_hooks(self) -> bool:  # noqa: D102
+        return bool(self._client)
+
+    @property
+    def has_execution_hooks(self) -> bool:  # noqa: D102
+        return bool(self._execution)
+
+    @property
+    def has_task_hooks(self) -> bool:  # noqa: D102
+        return bool(self._task)
+
+    @property
+    def has_push_hooks(self) -> bool:  # noqa: D102
+        return bool(self._push)
+
+    # --- server ---
+
+    async def before_handler_run(self, request: ServerRequest) -> None:  # noqa: D102
+        ran: list[ServerPlugin] = []
+        for plugin in self._server:
+            try:
+                await plugin.before_handler_run(request)
+            except Exception as e:
+                response = ServerResponse(
+                    request.method, None, request.context, error=e
+                )
+                for done in reversed(ran):
+                    await _run_safely(
+                        done,
+                        'after_handler_run',
+                        done.after_handler_run(response),
+                    )
+                raise
+            ran.append(plugin)
+
+    async def after_handler_run(self, response: ServerResponse) -> None:  # noqa: D102
+        for plugin in reversed(self._server):
+            await _run_safely(
+                plugin, 'after_handler_run', plugin.after_handler_run(response)
+            )
+
+    # --- client ---
+
+    async def before_client_request(self, request: ClientRequest) -> None:  # noqa: D102
+        ran: list[ClientPlugin] = []
+        for plugin in self._client:
+            try:
+                await plugin.before_client_request(request)
+            except Exception as e:
+                response = ClientResponse(
+                    request.method, None, request.context, error=e
+                )
+                for done in reversed(ran):
+                    await _run_safely(
+                        done,
+                        'after_client_request',
+                        done.after_client_request(response),
+                    )
+                raise
+            ran.append(plugin)
+
+    async def after_client_request(self, response: ClientResponse) -> None:  # noqa: D102
+        for plugin in reversed(self._client):
+            await _run_safely(
+                plugin,
+                'after_client_request',
+                plugin.after_client_request(response),
+            )
+
+    # --- execution ---
+
+    async def before_execution(self, request_context: RequestContext) -> None:  # noqa: D102
+        ran: list[ExecutionPlugin] = []
+        for plugin in self._execution:
+            try:
+                await plugin.before_execution(request_context)
+            except Exception as e:
+                for done in reversed(ran):
+                    await _run_safely(
+                        done,
+                        'after_execution',
+                        done.after_execution(request_context, e),
+                    )
+                raise
+            ran.append(plugin)
+
+    async def on_execution_event(  # noqa: D102
+        self, request_context: RequestContext, event: Event
+    ) -> None:
+        for plugin in self._execution:
+            await _run_safely(
+                plugin,
+                'on_execution_event',
+                plugin.on_execution_event(request_context, event),
+            )
+
+    async def after_execution(  # noqa: D102
+        self, request_context: RequestContext, error: BaseException | None
+    ) -> None:
+        for plugin in reversed(self._execution):
+            await _run_safely(
+                plugin,
+                'after_execution',
+                plugin.after_execution(request_context, error),
+            )
+
+    # --- task ---
+
+    async def on_task_event(self, info: TaskEventInfo) -> None:  # noqa: D102
+        for plugin in self._task:
+            await _run_safely(
+                plugin, 'on_task_event', plugin.on_task_event(info)
+            )
+
+    # --- push ---
+
+    async def before_push_send(self, request: PushRequest) -> None:  # noqa: D102
+        for plugin in self._push:
+            await plugin.before_push_send(request)
+
+    async def on_push_sent(self, result: PushResult) -> None:  # noqa: D102
+        for plugin in self._push:
+            await _run_safely(
+                plugin, 'on_push_sent', plugin.on_push_sent(result)
+            )
+
+
+def sequential(*plugins: Plugin) -> SequentialPluginManager:
+    """Returns a manager that runs ``plugins`` in the given order."""
+    return SequentialPluginManager(*plugins)
+
+
+_global_manager: PluginManager = SequentialPluginManager()
+
+
+def set_global(manager: PluginManager) -> None:
+    """Sets the manager used by handlers, clients and push senders created afterwards.
+
+    `DefaultRequestHandlerV2`, clients and `BasePushNotificationSender`
+    capture the manager when they are constructed, so call this once at
+    startup, before creating them.
+    """
+    global _global_manager  # noqa: PLW0603
+    if not isinstance(manager, PluginManager):
+        raise TypeError(
+            f'Expected a PluginManager, got {type(manager).__name__}; '
+            'wrap plugins with a2a.plugins.sequential(...)'
+        )
+    _global_manager = manager
+
+
+def get_global() -> PluginManager:
+    """Returns the global manager. Empty unless `set_global` was called."""
+    return _global_manager
diff --git a/src/a2a/plugins/types.py b/src/a2a/plugins/types.py
new file mode 100644
index 000000000..922dcdf0e
--- /dev/null
+++ b/src/a2a/plugins/types.py
@@ -0,0 +1,174 @@
+"""Argument types passed to plugin hooks.
+
+Hooks return ``None``. Per-call state lives in ``context.state`` (server and
+client) or ``PushRequest.state`` (push), which the SDK passes unchanged from a
+before-hook to the matching after-hook.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from a2a.client.client import ClientCallContext
+    from a2a.server.context import ServerCallContext
+    from a2a.server.events.event_queue import Event
+    from a2a.server.tasks.push_notification_sender import (
+        PushNotificationEvent,
+    )
+    from a2a.types.a2a_pb2 import AgentCard, Task, TaskState
+
+
+@dataclass
+class ServerRequest:
+    """An incoming request, passed to `ServerPlugin.before_handler_run`.
+
+    Attributes:
+        method: Method name, e.g. ``'send_message'`` or ``'get_task'``.
+        payload: The request proto, e.g. ``SendMessageRequest``.
+        context: The call context. For HTTP transports ``state['headers']``
+            holds the request headers.
+        agent_card: The agent card served by this handler.
+    """
+
+    method: str
+    payload: Any
+    context: ServerCallContext
+    agent_card: AgentCard | None = None
+
+
+@dataclass
+class ServerResponse:
+    """A handler result, passed to `ServerPlugin.after_handler_run`.
+
+    For a unary call the hook runs once with ``is_final=True``. For a stream
+    it runs once per event with ``is_stream_event=True, is_final=False`` and
+    once more with ``is_final=True`` and ``payload=None`` when the stream
+    ends, including on error or client disconnect.
+
+    Attributes:
+        method: Method name.
+        payload: The handler result or stream event, ``None`` on error or
+            stream end.
+        context: The same call context passed to `before_handler_run`.
+        error: The exception raised by the handler, if any.
+        is_stream_event: Whether ``payload`` is one event of a stream.
+        is_final: Whether this is the last call for the request.
+    """
+
+    method: str
+    payload: Any
+    context: ServerCallContext
+    error: BaseException | None = None
+    is_stream_event: bool = False
+    is_final: bool = True
+
+
+@dataclass
+class ClientRequest:
+    """An outgoing call, passed to `ClientPlugin.before_client_request`.
+
+    Attributes:
+        method: Method name, the same as on the server side and as passed
+            to interceptors.
+        payload: The request proto. Plugins may replace it.
+        agent_card: The card of the remote agent.
+        context: The call context. ``service_parameters`` holds the outgoing
+            headers.
+    """
+
+    method: str
+    payload: Any
+    agent_card: AgentCard
+    context: ClientCallContext
+
+
+@dataclass
+class ClientResponse:
+    """A call result, passed to `ClientPlugin.after_client_request`.
+
+    Follows the same ``is_stream_event`` / ``is_final`` rules as
+    `ServerResponse`.
+
+    Attributes:
+        method: Method name.
+        payload: The response or stream event, ``None`` on error or stream end.
+        context: The same call context passed to `before_client_request`.
+        error: The exception raised by the call, if any.
+        is_stream_event: Whether ``payload`` is one event of a stream.
+        is_final: Whether this is the last call for the request.
+    """
+
+    method: str
+    payload: Any
+    context: ClientCallContext
+    error: BaseException | None = None
+    is_stream_event: bool = False
+    is_final: bool = True
+
+
+@dataclass
+class TaskEventInfo:
+    """A successful task write, passed to `TaskObserverPlugin.on_task_event`.
+
+    Attributes:
+        task_id: ID of the task.
+        from_state: Persisted state before the write, ``None`` when the write
+            created the task.
+        to_state: State after the write. Equal to ``from_state`` for writes
+            that do not change the state, such as artifact updates.
+        event: The event that caused the write, ``None`` when the SDK wrote
+            the task without one.
+        task: The task after the write. This is the SDK's live object;
+            copy it if you keep it beyond the hook call.
+        context: Call context of the request that produced the write.
+    """
+
+    task_id: str
+    from_state: TaskState | None
+    to_state: TaskState
+    event: Event | None
+    task: Task
+    context: ServerCallContext
+
+
+@dataclass
+class PushRequest:
+    """One push delivery, passed to `PushPlugin.before_push_send`.
+
+    Attributes:
+        task_id: ID of the task.
+        url: Webhook URL.
+        headers: Outgoing HTTP headers. Plugins may add or change entries.
+        event: The event being pushed.
+        skip: Set to ``True`` to drop this delivery.
+        state: Per-delivery plugin state, available again in `PushResult`.
+    """
+
+    task_id: str
+    url: str
+    headers: dict[str, str]
+    event: PushNotificationEvent
+    skip: bool = False
+    state: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PushResult:
+    """The outcome of one push delivery, passed to `PushPlugin.on_push_sent`.
+
+    Attributes:
+        request: The `PushRequest` for this delivery.
+        duration_s: Duration of the HTTP request in seconds.
+        status_code: HTTP status code, ``None`` if no response was received.
+        error: The exception if delivery failed, ``None`` on success.
+        skipped: Whether a plugin dropped the delivery.
+    """
+
+    request: PushRequest
+    duration_s: float
+    status_code: int | None
+    error: BaseException | None
+    skipped: bool = False
diff --git a/src/a2a/server/__init__.py b/src/a2a/server/__init__.py
index e69de29bb..6bd0c772a 100644
--- a/src/a2a/server/__init__.py
+++ b/src/a2a/server/__init__.py
@@ -0,0 +1 @@
+"""Server-side components for implementing an A2A agent."""
diff --git a/src/a2a/server/agent_execution/__init__.py b/src/a2a/server/agent_execution/__init__.py
index 88660d627..e00df6492 100644
--- a/src/a2a/server/agent_execution/__init__.py
+++ b/src/a2a/server/agent_execution/__init__.py
@@ -1,5 +1,18 @@
+"""Components for executing agent logic within the A2A server."""
+
 from a2a.server.agent_execution.agent_executor import AgentExecutor
 from a2a.server.agent_execution.context import RequestContext
+from a2a.server.agent_execution.request_context_builder import (
+    RequestContextBuilder,
+)
+from a2a.server.agent_execution.simple_request_context_builder import (
+    SimpleRequestContextBuilder,
+)
 
 
-__all__ = ['AgentExecutor', 'RequestContext']
+__all__ = [
+    'AgentExecutor',
+    'RequestContext',
+    'RequestContextBuilder',
+    'SimpleRequestContextBuilder',
+]
diff --git a/src/a2a/server/agent_execution/active_task.py b/src/a2a/server/agent_execution/active_task.py
new file mode 100644
index 000000000..7016cd169
--- /dev/null
+++ b/src/a2a/server/agent_execution/active_task.py
@@ -0,0 +1,1134 @@
+# ruff: noqa: TRY301, SLF001
+"""Active Task execution and data flow architecture.
+
+This module manages the lifecycle, execution, and data flow of an active A2A task.
+
+High-Level Architecture:
+- `AgentExecutor`: An interface with two main methods, `execute(...)` and `cancel(...)`,
+  responsible for running the core agent logic.
+- `ActiveTask`: Coordinates the execution. It runs a main agent loop in `ActiveTask._run_producer()`.
+
+Data Flow and Event Handling:
+1. Producer (`ActiveTask._run_producer`):
+   - Listens for incoming requests from `ActiveTask._request_queue`.
+   - Acquires `ActiveTask._request_lock` to ensure requests are processed sequentially.
+   - Calls `AgentExecutor.execute()` passing `ActiveTask._event_queue_agent` as the primary communication channel.
+   - Enqueues internal lifecycle events (e.g., `_RequestStarted`, `_RequestCompleted`) and
+     exceptions to the same `ActiveTask._event_queue_agent`.
+
+2. Consumer (`EventConsumer`):
+   - Consumes events from `ActiveTask._event_queue_agent`.
+   - Processes all events, updating task state and the database (`TaskManager`).
+   - Upon receiving `_RequestCompleted`, it releases `ActiveTask._request_lock`, making the producer
+     ready to process the next queued request.
+   - Propagates relevant agent updates and state changes to `ActiveTask._event_queue_subscribers`.
+   - Exception Handling: Re-raises exceptions dequeued from the agent queue, or raises its own validation
+     errors (e.g., 'Received Message object in task mode.'). In case of failure, it updates the task
+     state to failed and propagates the exception to `ActiveTask._event_queue_subscribers`.
+
+3. Subscribers (`ActiveTask.subscribe`):
+   - `ActiveTask._event_queue_subscribers` is not consumed directly. Instead, it is consumed by tapped
+     queues created within the `ActiveTask.subscribe()` method.
+   - The `ActiveTask.subscribe()` method is also used to actively run requests, creating a temporary
+     subscription that yields events and automatically finishes once the request is completed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import logging
+import uuid
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, cast
+
+from a2a.server.agent_execution.context import RequestContext
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Callable
+
+    from a2a.server.agent_execution.agent_executor import AgentExecutor
+    from a2a.server.cluster.event_stream import TaskEventStream
+    from a2a.server.context import ServerCallContext
+    from a2a.server.tasks.push_notification_sender import (
+        PushNotificationSender,
+    )
+    from a2a.server.tasks.task_manager import TaskManager
+
+from a2a.server.cluster.event_stream import (
+    VersionedEvent,
+    _stream_accepts_context,
+)
+from a2a.server.cluster.task_store import ConcurrentTaskModificationError
+from a2a.server.events.event_queue_v2 import (
+    AsyncQueue,
+    Event,
+    EventQueueSource,
+    QueueShutDown,
+    create_async_queue,
+)
+from a2a.server.tasks import PushNotificationEvent
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    Message,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import (
+    INTERRUPTED_TASK_STATES,
+    TERMINAL_TASK_STATES,
+)
+from a2a.utils.errors import (
+    InternalError,
+    InvalidAgentResponseError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class _RequestStarted:
+    def __init__(self, request_id: uuid.UUID, request_context: RequestContext):
+        self.request_id = request_id
+        self.request_context = request_context
+
+
+class _RequestCompleted:
+    def __init__(self, request_id: uuid.UUID):
+        self.request_id = request_id
+
+
+class EventConsumer:
+    """Consumes events from the agent and updates system state."""
+
+    def __init__(self, active_task: ActiveTask) -> None:
+        self.active_task = active_task
+        self.task_mode: bool | None = None
+        self.message_to_save: Message | None = None
+        # Set when the producer failed, so a request that failed before any
+        # task was created still leaves a FAILED task behind.
+        self.producer_failed = False
+
+    async def run(self) -> None:
+        """Consumes events from the agent and updates system state."""
+        logger.debug('Consumer[%s]: Started', self.active_task._task_id)
+        try:
+            while True:
+                logger.debug(
+                    'Consumer[%s]: Waiting for event',
+                    self.active_task._task_id,
+                )
+                event = (
+                    await self.active_task._event_queue_agent.dequeue_event()
+                )
+                logger.debug(
+                    'Consumer[%s]: Dequeued event %s',
+                    self.active_task._task_id,
+                    type(event).__name__,
+                )
+
+                await self._process_event(event)
+
+        except QueueShutDown:
+            logger.debug(
+                'Consumer[%s]: Event queue shut down',
+                self.active_task._task_id,
+            )
+        except Exception as e:
+            logger.exception('Consumer[%s]: Failed', self.active_task._task_id)
+
+            error: Exception = e
+            if isinstance(e, ConcurrentTaskModificationError):
+                # Other writers kept advancing the task; report a protocol error.
+                error = InternalError(message=str(e))
+
+            updated_task = None
+            try:
+                updated_task = await self._write_failed_status()
+            finally:
+                # Subscribers must always hear about the failure, or the
+                # request waiting on them never returns.
+                await self._enqueue_to_subscribers(
+                    cast('Event', error), updated_task
+                )
+
+    async def _write_failed_status(self) -> Task | None:
+        """Records FAILED once a failure ends the event stream.
+
+        After a producer failure this runs once every event the executor
+        enqueued before raising has been processed, so the write lands in
+        order. There are three cases:
+
+        - The request failed before a task was created: create one as FAILED.
+        - No task exists and the failure is the consumer's own, or the task
+          already reached a terminal state: nothing is written.
+        - Otherwise: the existing task is marked FAILED.
+        """
+        task_manager = self.active_task._task_manager
+        task = await task_manager.get_task()
+        if task is None and self.producer_failed:
+            task = await task_manager.ensure_task_id(
+                self.active_task._task_id, task_manager.context_id or ''
+            )
+            if task.status.state not in TERMINAL_TASK_STATES:
+                task.status.state = TaskState.TASK_STATE_FAILED
+                task.status.timestamp.FromDatetime(datetime.now(timezone.utc))
+                await task_manager.save_task_event(task)
+            self.active_task._task_created.set()
+            return task
+        if not task or task.status.state in TERMINAL_TASK_STATES:
+            return None
+        # Stamped with the failure time, which DatabaseTaskStore also uses for
+        # last_updated.
+        status = TaskStatus(state=TaskState.TASK_STATE_FAILED)
+        status.timestamp.FromDatetime(datetime.now(timezone.utc))
+        handled_event = TaskStatusUpdateEvent(
+            task_id=task.id,
+            context_id=task.context_id,
+            status=status,
+        )
+        try:
+            # Not _handle_task_event: that validates what the agent sent, and
+            # this write must land even after the agent replied with a Message.
+            await self._handle_task_modification_event(handled_event)
+            return await task_manager.get_task()
+        except ConcurrentTaskModificationError:
+            # Another writer advanced the task; keep its state.
+            self.active_task._task_manager.invalidate()
+            return None
+
+    async def _process_event(self, event: Event) -> None:
+        try:
+            await self._process_event_inner(event)
+        except ConcurrentTaskModificationError:
+            # Another writer advanced this task
+            logger.info(
+                'Consumer[%s]: concurrent modification, reloading',
+                self.active_task._task_id,
+            )
+            self.active_task._task_manager.invalidate()
+            task = await self.active_task._task_manager.get_task()
+            if task is not None and task.status.state in TERMINAL_TASK_STATES:
+                await self._enqueue_to_subscribers(task, task)
+                producer = self.active_task._producer_task
+                if producer is not None and not producer.done():
+                    producer.cancel()
+                await self._handle_terminal_state(task)
+                await self.active_task._event_queue_subscribers.close(
+                    immediate=False
+                )
+                return
+            await self._process_event_inner(event)
+
+    async def _process_event_inner(self, event: Event) -> None:
+        updated_task = None
+        handled_event: (
+            Task
+            | TaskStatusUpdateEvent
+            | TaskArtifactUpdateEvent
+            | PushNotificationEvent
+            | None
+        ) = None
+
+        if isinstance(event, _RequestCompleted):
+            logger.debug(
+                'Consumer[%s]: Request completed', self.active_task._task_id
+            )
+            self.active_task._request_lock.release()
+            self.active_task.schedule_idle_release()
+        elif isinstance(event, _RequestStarted):
+            logger.debug(
+                'Consumer[%s]: Request started', self.active_task._task_id
+            )
+            self.message_to_save = event.request_context.message
+        elif isinstance(event, BaseException):
+            # Only the producer enqueues exceptions, when a request fails.
+            self.producer_failed = True
+            raise event
+        elif isinstance(event, Message):
+            self._handle_message_event(event)
+        elif isinstance(
+            event,
+            TaskStatusUpdateEvent
+            | TaskArtifactUpdateEvent
+            | PushNotificationEvent
+            | Task,
+        ):
+            if isinstance(
+                event, TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+            ):
+                current = await self.active_task._task_manager.get_task()
+                if (
+                    current is not None
+                    and current.status.state in TERMINAL_TASK_STATES
+                ):
+                    # A terminal task's status is final. New status updates should be dropped
+                    logger.debug(
+                        'Consumer[%s]: dropping %s for an already-terminal task',
+                        self.active_task._task_id,
+                        type(event).__name__,
+                    )
+                    self.active_task._event_queue_agent.task_done()
+                    return
+            updated_task = await self._handle_task_event(event)
+            handled_event = updated_task if isinstance(event, Task) else event
+
+        if updated_task is not None and handled_event is not None:
+            await self._update_task_state(updated_task, handled_event)
+            self.active_task._task_created.set()
+
+        await self._enqueue_to_subscribers(event, updated_task)
+
+        if isinstance(event, Message):
+            self._handle_message_completion()
+
+    def _handle_message_completion(self) -> None:
+        # A direct Message has no task to continue, so finish like a terminal state.
+        logger.debug(
+            'Consumer[%s]: Message response, finishing',
+            self.active_task._task_id,
+        )
+        self.active_task._is_finished.set()
+        self.active_task._request_queue.shutdown(immediate=True)
+
+    def _handle_message_event(self, event: Message) -> None:
+        if self.task_mode is True:
+            raise InvalidAgentResponseError(
+                'Received Message object in task mode. Use TaskStatusUpdateEvent or TaskArtifactUpdateEvent instead.'
+            )
+        if self.task_mode is False:
+            raise InvalidAgentResponseError(
+                'Multiple Message objects received.'
+            )
+        self.task_mode = False
+
+    async def _handle_task_event(
+        self,
+        event: Task
+        | TaskStatusUpdateEvent
+        | TaskArtifactUpdateEvent
+        | PushNotificationEvent,
+    ) -> Task:
+        if self.task_mode is False:
+            raise InvalidAgentResponseError(
+                f'Received {type(event).__name__} in message mode. Use Task with TaskStatusUpdateEvent and TaskArtifactUpdateEvent instead.'
+            )
+
+        if isinstance(event, Task):
+            await self._handle_initial_task(event)
+        else:
+            await self._handle_task_modification_event(event)
+
+        self.task_mode = True
+        task = await self.active_task._task_manager.get_task()
+        if task is None:
+            raise RuntimeError(f'Task {self.active_task.task_id} not found')
+        return task
+
+    async def _handle_initial_task(self, event: Task) -> None:
+        existing_task = await self.active_task._task_manager.get_task()
+        if existing_task:
+            logger.error(
+                'Task %s already exists. Ignoring task replacement.',
+                self.active_task._task_id,
+            )
+        else:
+            await self.active_task._task_manager.save_task_event(event)
+        self.message_to_save = None
+
+    async def _handle_task_modification_event(
+        self,
+        event: TaskStatusUpdateEvent
+        | TaskArtifactUpdateEvent
+        | PushNotificationEvent,
+    ) -> None:
+        if (
+            isinstance(event, TaskStatusUpdateEvent)
+            and not self.active_task._task_created.is_set()
+        ):
+            task = await self.active_task._task_manager.get_task()
+            if task is None:
+                raise InvalidAgentResponseError(
+                    f'Agent should enqueue Task before {type(event).__name__} event'
+                )
+
+        updated_task = await self.active_task._task_manager.ensure_task_id(
+            self.active_task._task_id,
+            event.context_id,
+        )
+
+        if self.message_to_save is not None:
+            message_already_saved = any(
+                message.message_id == self.message_to_save.message_id
+                for message in updated_task.history
+            )
+            if not message_already_saved:
+                updated_task = (
+                    self.active_task._task_manager.update_with_message(
+                        self.message_to_save,
+                        updated_task,
+                    )
+                )
+                await self.active_task._task_manager.save_task_event(
+                    updated_task
+                )
+            self.message_to_save = None
+
+        self.active_task._task_manager.context_id = event.context_id
+        await self.active_task._task_manager.process(event)
+
+    async def _update_task_state(
+        self,
+        updated_task: Task,
+        event: Task
+        | TaskStatusUpdateEvent
+        | TaskArtifactUpdateEvent
+        | PushNotificationEvent,
+    ) -> None:
+        is_terminal = updated_task.status.state in TERMINAL_TASK_STATES
+
+        if is_terminal:
+            await self._handle_terminal_state(updated_task)
+
+        if (
+            self.active_task._push_sender
+            and self.active_task._task_id
+            and isinstance(event, PushNotificationEvent)
+        ):
+            logger.debug(
+                'Consumer[%s]: Sending push notification',
+                self.active_task._task_id,
+            )
+            try:
+                await self.active_task._push_sender.send_notification(
+                    self.active_task._task_id, event
+                )
+            except Exception:
+                # Push delivery is best-effort: a sender failure must not
+                # fail the task or disturb the event stream. This guard is
+                # defense-in-depth on top of the boundary inside
+                # BasePushNotificationSender, and also protects against
+                # custom PushNotificationSender implementations.
+                logger.exception(
+                    'Consumer[%s]: Push notification sender raised; '
+                    'ignoring the failure.',
+                    self.active_task._task_id,
+                )
+
+    async def _handle_terminal_state(self, updated_task: Task) -> None:
+        logger.debug(
+            'Consumer[%s]: Reached terminal state %s',
+            self.active_task._task_id,
+            updated_task.status.state,
+        )
+        self.active_task._is_finished.set()
+        self.active_task._request_queue.shutdown(immediate=True)
+
+    async def _enqueue_to_subscribers(
+        self, event: Event, updated_task: Task | None
+    ) -> None:
+        if updated_task is not None:
+            updated_task_copy = Task()
+            updated_task_copy.CopyFrom(updated_task)
+            if event is updated_task:
+                event = updated_task_copy
+            updated_task = updated_task_copy
+
+        logger.debug(
+            'Consumer[%s]: Enqueuing\nEvent: %s\nUpdated Task: %s\n',
+            self.active_task._task_id,
+            event,
+            updated_task,
+        )
+        await self.active_task._event_queue_subscribers.enqueue_event(
+            cast('Any', (event, updated_task))
+        )
+
+        # Fan out to other replicas
+        stream = self.active_task._event_stream
+        if stream is not None and isinstance(event, Event):
+            version = self.active_task._task_manager.current_version
+            versioned_event = VersionedEvent(event=event, version=version)
+            task_id = self.active_task._task_id
+            if _stream_accepts_context(stream, 'publish'):
+                # TODO(ISSUE #1374): remove this check once ServerCallContext is a required parameter on TaskEventStream.
+                await stream.publish(
+                    task_id,
+                    versioned_event,
+                    context=self.active_task._task_manager._call_context,  # ty:ignore[unknown-argument]
+                )
+            else:
+                await stream.publish(task_id, versioned_event)
+
+        self.active_task._event_queue_agent.task_done()
+
+
+class ActiveTask:
+    """Manages the lifecycle and execution of an active A2A task.
+
+    It coordinates between the agent's execution (the producer), the
+    persistence and state management (the TaskManager), and the event
+    distribution to subscribers (the consumer).
+
+    Concurrency Guarantees:
+    - This class is designed to be highly concurrent. It manages an internal
+      producer-consumer model using `asyncio.Task`s.
+    - `self._lock` (asyncio.Lock) ensures mutually exclusive access for critical
+      lifecycle state changes, such as starting the task, subscribing, and
+      determining if cleanup is safe to trigger.
+    - `self._is_finished` (asyncio.Event) provides a thread-safe, non-blocking way
+      for external observers and internal loops to check if the ActiveTask has
+      permanently ceased execution and closed its queues.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        agent_executor: AgentExecutor,
+        task_id: str,
+        task_manager: TaskManager,
+        push_sender: PushNotificationSender | None = None,
+        on_cleanup: Callable[[ActiveTask], None] | None = None,
+        event_stream: TaskEventStream | None = None,
+        interrupted_task_timeout: float | None = None,
+    ) -> None:
+        """Initializes the ActiveTask.
+
+        Args:
+            agent_executor: The executor to run the agent logic (producer).
+            task_id: The unique identifier of the task being managed.
+            task_manager: The manager for task state and database persistence.
+            push_sender: Optional sender for out-of-band push notifications.
+            on_cleanup: Optional callback triggered when the task is fully finished
+                        and the last subscriber has disconnected. Used to prune
+                        the task from the ActiveTaskRegistry.
+            event_stream: Optional cross-replica stream; applied events are
+                        published to it so other replicas can observe them.
+            interrupted_task_timeout: Optional seconds after which an idle
+                        interrupted task is finished; ``None`` disables it.
+        """
+        # --- Core Dependencies ---
+        self._agent_executor = agent_executor
+        self._task_id = task_id
+        self._event_queue_agent = EventQueueSource()
+        self._event_queue_subscribers = EventQueueSource(
+            create_default_sink=False
+        )
+        self._task_manager = task_manager
+        self._push_sender = push_sender
+        self._on_cleanup = on_cleanup
+        self._event_stream = event_stream
+        self._interrupted_task_timeout = interrupted_task_timeout
+        # Pending timer that releases a task parked in an interrupted state.
+        self._idle_release_task: asyncio.Task[None] | None = None
+
+        # --- Synchronization Primitives ---
+        # `_lock` protects structural lifecycle changes: start(), subscribe() counting,
+        # and _maybe_cleanup() race conditions.
+        self._lock = asyncio.Lock()
+
+        # `_request_lock` protects parallel request processing.
+        self._request_lock = asyncio.Lock()
+
+        # _task_created is set when initial version of task is stored in DB.
+        self._task_created = asyncio.Event()
+
+        # `_is_finished` is set EXACTLY ONCE when the consumer loop exits, signifying
+        # the absolute end of the task's active lifecycle.
+        self._is_finished = asyncio.Event()
+
+        # --- Lifecycle State ---
+        # The background task executing the agent logic.
+        self._producer_task: asyncio.Task[None] | None = None
+        # The background task reading from _event_queue and updating the DB.
+        self._consumer_task: asyncio.Task[None] | None = None
+
+        # Tracks how many active SSE/gRPC streams are currently tailing this task.
+        # Protected by `_lock`.
+        self._reference_count = 0
+
+        # Queue for incoming requests
+        self._request_queue: AsyncQueue[
+            tuple[RequestContext, uuid.UUID, contextvars.Context]
+        ] = create_async_queue()
+
+    @property
+    def task_id(self) -> str:
+        """The ID of the task."""
+        return self._task_id
+
+    @property
+    def is_finished(self) -> bool:
+        """Whether the task's active lifecycle has ended."""
+        return self._is_finished.is_set()
+
+    async def enqueue_request(
+        self, request_context: RequestContext
+    ) -> uuid.UUID:
+        """Enqueues a request for the active task to process.
+
+        The caller's contextvars are captured so the producer runs
+        `AgentExecutor.execute` in the context of the request that sent the
+        message, not the request that started the producer.
+        """
+        request_id = uuid.uuid4()
+        await self._request_queue.put(
+            (request_context, request_id, contextvars.copy_context())
+        )
+        return request_id
+
+    async def start(
+        self,
+        call_context: ServerCallContext,
+        create_task_if_missing: bool = False,
+    ) -> None:
+        """Starts the active task background processes.
+
+        Concurrency Guarantee:
+        Uses `self._lock` to ensure the producer and consumer tasks are strictly
+        singleton instances for the lifetime of this ActiveTask.
+        """
+        logger.debug('ActiveTask[%s]: Starting', self._task_id)
+        async with self._lock:
+            if self._is_finished.is_set():
+                raise UnsupportedOperationError(
+                    f'Task {self._task_id} is already completed. Cannot start it again.'
+                )
+
+            if (
+                self._producer_task is not None
+                and self._consumer_task is not None
+            ):
+                logger.debug(
+                    'ActiveTask[%s]: Already started, ignoring start request',
+                    self._task_id,
+                )
+                return
+
+            logger.debug(
+                'ActiveTask[%s]: Executing setup (call_context: %s, create_task_if_missing: %s)',
+                self._task_id,
+                call_context,
+                create_task_if_missing,
+            )
+            try:
+                self._task_manager._call_context = call_context
+                task = await self._task_manager.get_task()
+                logger.debug('TASK (start): %s', task)
+
+                if task:
+                    self._task_created.set()
+                    if task.status.state in TERMINAL_TASK_STATES:
+                        raise UnsupportedOperationError(
+                            message=f'Task {task.id} is in terminal state: {TaskState.Name(task.status.state)}'
+                        )
+                elif not create_task_if_missing:
+                    raise TaskNotFoundError
+
+            except Exception:
+                logger.debug(
+                    'ActiveTask[%s]: Setup failed, cleaning up',
+                    self._task_id,
+                )
+                self._is_finished.set()
+                await self._event_queue_agent.close(immediate=True)
+                await self._event_queue_subscribers.close(immediate=True)
+                if self._reference_count == 0 and self._on_cleanup:
+                    self._on_cleanup(self)
+                raise
+
+            # Spawn the background tasks that drive the lifecycle.
+            self._reference_count += 1
+            self._producer_task = asyncio.create_task(
+                self._run_producer(), name=f'producer:{self._task_id}'
+            )
+            self._consumer_task = asyncio.create_task(
+                self._run_consumer(), name=f'consumer:{self._task_id}'
+            )
+            logger.debug(
+                'ActiveTask[%s]: Background tasks created', self._task_id
+            )
+
+    async def _run_producer(self) -> None:
+        """Executes the agent logic.
+
+        This method encapsulates the external `AgentExecutor.execute` call. It ensures
+        that regardless of how the agent finishes (success, unhandled exception, or
+        cancellation), the underlying `_event_queue` is safely closed, which signals
+        the consumer to wind down.
+
+        Concurrency Guarantee:
+        Runs as a detached asyncio.Task. Safe to cancel.
+        """
+        logger.debug('Producer[%s]: Started', self._task_id)
+        try:
+            while True:
+                (
+                    request_context,
+                    request_id,
+                    sender_context,
+                ) = await self._request_queue.get()
+                await self._request_lock.acquire()
+                # TODO: Should we create task manager every time?
+                self._task_manager._call_context = request_context.call_context
+
+                # Drop the cached snapshot and re-read to pick
+                # up state another replica may have advanced.
+                self._task_manager.invalidate()
+                task = await self._task_manager.get_task()
+                # In cluster mode another replica may have finished the task
+                # while this one waited for input.
+                if (
+                    self._event_stream is not None
+                    and task is not None
+                    and task.status.state in TERMINAL_TASK_STATES
+                ):
+                    raise UnsupportedOperationError(
+                        message=f'Task {task.id} is in terminal state: {TaskState.Name(task.status.state)}'
+                    )
+                request_context.current_task = task
+
+                logger.debug(
+                    'Producer[%s]: Executing agent task %s',
+                    self._task_id,
+                    request_context.current_task,
+                )
+
+                try:
+                    await self._event_queue_agent.enqueue_event(
+                        cast(
+                            'Event',
+                            _RequestStarted(request_id, request_context),
+                        )
+                    )
+                    # Awaiting the child task propagates producer cancellation.
+                    await sender_context.run(
+                        asyncio.create_task,
+                        self._agent_executor.execute(
+                            request_context, self._event_queue_agent
+                        ),
+                    )
+                    logger.debug(
+                        'Producer[%s]: Execution finished successfully',
+                        self._task_id,
+                    )
+                    await self._event_queue_agent.enqueue_event(
+                        cast('Event', _RequestCompleted(request_id))
+                    )
+                finally:
+                    self._request_queue.task_done()
+        except asyncio.CancelledError:
+            logger.debug('Producer[%s]: Cancelled', self._task_id)
+
+        except QueueShutDown:
+            logger.debug('Producer[%s]: Queue shut down', self._task_id)
+
+        except Exception as e:
+            logger.exception(
+                'Producer[%s]: Execution failed',
+                self._task_id,
+            )
+            # The consumer writes FAILED: writing here would race its save of
+            # an event the executor enqueued just before raising.
+            await self._event_queue_agent.enqueue_event(cast('Event', e))
+
+        finally:
+            self._request_queue.shutdown(immediate=True)
+            await self._event_queue_agent.close(immediate=False)
+            await self._event_queue_subscribers.close(immediate=False)
+            logger.debug('Producer[%s]: Completed', self._task_id)
+
+    async def _run_consumer(self) -> None:
+        """Consumes events from the agent and updates system state."""
+        try:
+            await EventConsumer(self).run()
+        finally:
+            self._is_finished.set()
+            self.cancel_idle_release()
+            self._request_queue.shutdown(immediate=True)
+            await self._event_queue_agent.close(immediate=True)
+
+            if self._producer_task and not self._producer_task.done():
+                try:
+                    await self._producer_task
+                except asyncio.CancelledError:
+                    pass
+                except Exception as e:  # noqa: BLE001
+                    logger.debug(
+                        'Consumer[%s]: Awaited producer_task raised %r',
+                        self._task_id,
+                        e,
+                    )
+
+            async with self._lock:
+                self._reference_count -= 1
+            logger.debug('Consumer[%s]: Finishing', self._task_id)
+            await self._maybe_cleanup()
+
+    async def subscribe(  # noqa: PLR0915
+        self,
+        *,
+        request: RequestContext | None = None,
+        include_initial_task: bool = False,
+        replace_status_update_with_task: bool = False,
+    ) -> AsyncGenerator[Event, None]:
+        """Creates a queue tap and yields events as they are produced.
+
+        Concurrency Guarantee:
+        Uses `_lock` to safely increment and decrement `_reference_count`.
+        Safely detaches its queue tap when the client disconnects or the task finishes,
+        triggering `_maybe_cleanup()` to potentially garbage collect the ActiveTask.
+        """
+        logger.debug('Subscribe[%s]: New subscriber', self._task_id)
+
+        self.cancel_idle_release()
+        async with self._lock:
+            if self._is_finished.is_set():
+                raise UnsupportedOperationError(
+                    f'Task {self._task_id} is already completed.'
+                )
+            self._reference_count += 1
+            logger.debug(
+                'Subscribe[%s]: Subscribers count: %d',
+                self._task_id,
+                self._reference_count,
+            )
+
+        # evict_on_full=True: a subscriber that falls behind is dropped, so it
+        # cannot wedge dispatch for the others. See _deliver_to_sink().
+        tapped_queue = await self._event_queue_subscribers.tap(
+            evict_on_full=True
+        )
+        request_id = await self.enqueue_request(request) if request else None
+
+        try:
+            if include_initial_task:
+                logger.debug(
+                    'Subscribe[%s]: Including initial task',
+                    self._task_id,
+                )
+                task = await self.get_task()
+                yield task
+
+            while True:
+                try:
+                    dequeued = await tapped_queue.dequeue_event()
+                    event, updated_task = cast('Any', dequeued)
+                    logger.debug(
+                        'Subscriber[%s] Dequeued event [%s]:\n %s\nUpdated task:\n%s\n',
+                        self._task_id,
+                        type(event).__name__,
+                        event,
+                        updated_task,
+                    )
+                    if isinstance(event, BaseException):
+                        logger.debug(
+                            'Subscriber[%s]: Raising exception: %s',
+                            self._task_id,
+                            event,
+                        )
+                        tapped_queue.task_done()
+                        raise event
+
+                    if replace_status_update_with_task and isinstance(
+                        event, TaskStatusUpdateEvent
+                    ):
+                        logger.debug(
+                            'Subscriber[%s]: Replacing TaskStatusUpdateEvent with Task: %s',
+                            self._task_id,
+                            updated_task,
+                        )
+                        event = updated_task
+                    # Acknowledge internal lifecycle events before skipping them.
+                    if isinstance(event, _RequestStarted | _RequestCompleted):
+                        tapped_queue.task_done()
+                    if isinstance(event, _RequestCompleted):
+                        if (
+                            request_id is not None
+                            and event.request_id == request_id
+                        ):
+                            logger.debug(
+                                'Subscriber[%s]: Request completed',
+                                self._task_id,
+                            )
+                            return
+                        continue
+                    elif isinstance(event, _RequestStarted):
+                        logger.debug(
+                            'Subscriber[%s]: Request started',
+                            self._task_id,
+                        )
+                        continue
+                    try:
+                        yield event
+                    finally:
+                        tapped_queue.task_done()
+                except QueueShutDown:
+                    break
+        finally:
+            logger.debug('Subscribe[%s]: Unsubscribing', self._task_id)
+            await tapped_queue.close(immediate=True)
+            async with self._lock:
+                self._reference_count -= 1
+            # Evaluate if this was the last subscriber on a finished task.
+            await self._maybe_cleanup()
+            self.schedule_idle_release()
+
+    async def cancel(
+        self,
+        call_context: ServerCallContext,
+        request: CancelTaskRequest | None = None,
+    ) -> Task:
+        """Cancels the running active task.
+
+        The returned task carries a terminal state, which is written to the
+        task store. That write is not guaranteed to reach an active subscriber
+        stream: by the time cancel writes it the event queues may already be
+        closed, so a client that was streaming may have to re-read the task to
+        observe the terminal state.
+
+        Concurrency Guarantee:
+        Uses `_lock` to ensure we don't attempt to cancel a producer that is
+        already winding down or hasn't started. It fires the cancellation signal
+        and blocks until the consumer processes the cancellation events.
+        """
+        logger.debug('Cancel[%s]: Cancelling task', self._task_id)
+
+        # TODO: Conflicts with call_context on the pending request.
+        self._task_manager._call_context = call_context
+
+        task = await self._task_manager.get_task()
+        request_context = RequestContext(
+            call_context=call_context,
+            request=request,
+            task_id=self._task_id,
+            context_id=task.context_id if task else None,
+            task=task,
+        )
+
+        async with self._lock:
+            if not self._is_finished.is_set() and self._producer_task:
+                logger.debug(
+                    'Cancel[%s]: Cancelling producer task', self._task_id
+                )
+                # Await the executor's cancel before cancelling the producer,
+                # so the component that owns the task's terminal state can
+                # still write to the still-open event queue. Cancelling the
+                # producer first can tear the queue down first and drop that
+                # write. Mirrors the V1 handler ordering. The producer cancel
+                # is in a finally so it still runs when executor.cancel() raises
+                # a BaseException such as asyncio.CancelledError, which
+                # `except Exception` does not catch; otherwise the producer
+                # would leak as a pending task. Cancelling after
+                # _mark_task_as_failed also keeps the FAILED write ahead of the
+                # queue teardown, so it is not dropped as QueueShutDown.
+                #
+                # Residual: if executor.cancel() raises a BaseException (e.g.
+                # asyncio.CancelledError), it propagates out of cancel() from
+                # the finally before the _is_finished.wait() and the CANCELED
+                # write below, leaving the task non-terminal with no producer
+                # behind it. This is not the #1170 silent-success shape (the
+                # caller receives the exception), and it is recoverable: a
+                # later cancel() takes the else branch and reaches the
+                # terminal write.
+                try:
+                    await self._agent_executor.cancel(
+                        request_context, self._event_queue_agent
+                    )
+                except Exception as e:
+                    logger.exception(
+                        'Cancel[%s]: Agent cancel failed', self._task_id
+                    )
+                    await self._mark_task_as_failed(e)
+                    raise
+                finally:
+                    self._producer_task.cancel()
+            else:
+                logger.debug(
+                    'Cancel[%s]: Task already finished [%s] or producer not started [%s], not cancelling',
+                    self._task_id,
+                    self._is_finished.is_set(),
+                    self._producer_task,
+                )
+
+        await self._is_finished.wait()
+        self._task_manager.invalidate()
+        task = await self._task_manager.get_task()
+        if not task:
+            raise RuntimeError('Task should have been created')
+        # A cleanup-only executor.cancel() may not write a terminal state, and
+        # a task parked in a non-terminal state (e.g. input-required) has no
+        # running producer to write one either. Close it out as CANCELED so a
+        # caller that cancelled is never left polling a live task. Mirrors the
+        # V1 handler, which made a non-cancelled outcome visible instead of
+        # reporting success and changing nothing.
+        if task.status.state not in TERMINAL_TASK_STATES:
+            # Write a copy rather than mutating the task in place: get_task()
+            # returns the shared _task_manager._current_task, which may already
+            # have been yielded to a subscriber. Copying keeps THIS terminal
+            # write off the yielded reference. Status and artifact events are
+            # applied to a copy too (TaskManager.save_task_event), but a Task
+            # event or update_with_message still writes the object it is given.
+            # Making every write copy-on-yield is tracked in #1175 and #1191.
+            updated = Task()
+            updated.CopyFrom(task)
+            updated.status.state = TaskState.TASK_STATE_CANCELED
+            await self._task_manager.save_task_event(updated)
+            task = updated
+        return task
+
+    async def aclose(self) -> None:
+        """Force-closes the task's queues and drains its background tasks.
+
+        Provides a bounded, public teardown for the producer and consumer
+        ``asyncio.Task``s spawned in ``start()``. Without it, a producer
+        wedged in its ``finally`` closing an abandoned subscriber sink can
+        survive until event-loop shutdown and surface as
+        ``Task was destroyed but it is pending!``.
+
+        Always forces: the queues are closed with ``immediate=True`` and the
+        background tasks are cancelled, so teardown is bounded even when a
+        subscriber sink was never drained. It is safe to call multiple times.
+        """
+        # Shut down the request queue first, mirroring the producer's
+        # ``finally``. If `start()` was never called, the producer/consumer
+        # ``finally`` blocks never run, and without this a caller parked in
+        # `enqueue_request()` would wait forever.
+        self._request_queue.shutdown(immediate=True)
+        await self._event_queue_agent.close(immediate=True)
+        await self._event_queue_subscribers.close(immediate=True)
+        # Set `_is_finished` and collect the background tasks under `_lock` so
+        # this is mutually exclusive with `start()`, which refuses to spawn
+        # once `_is_finished` is set. The lock is released before awaiting the
+        # tasks, because their teardown re-acquires it.
+        async with self._lock:
+            self._is_finished.set()
+            self.cancel_idle_release()
+            background_tasks = [
+                task
+                for task in (self._producer_task, self._consumer_task)
+                if task is not None
+            ]
+            for task in background_tasks:
+                task.cancel()
+        if background_tasks:
+            results = await asyncio.gather(
+                *background_tasks, return_exceptions=True
+            )
+            for result in results:
+                # CancelledError is a BaseException, so it is excluded here.
+                if isinstance(result, Exception):
+                    logger.error('Error during aclose', exc_info=result)
+
+    def schedule_idle_release(self) -> None:
+        """(Re)starts the timer that releases a parked interrupted task."""
+        if self._interrupted_task_timeout is None or self._is_finished.is_set():
+            return
+        self.cancel_idle_release()
+        self._idle_release_task = asyncio.create_task(
+            self._release_when_idle(self._interrupted_task_timeout),
+            name=f'idle-release:{self._task_id}',
+        )
+
+    def cancel_idle_release(self) -> None:
+        """Stops the timer that releases a parked interrupted task, if any."""
+        if self._idle_release_task is not None:
+            self._idle_release_task.cancel()
+            self._idle_release_task = None
+
+    async def _release_when_idle(self, timeout: float) -> None:
+        """Finishes the task if it is still parked after `timeout` seconds."""
+        try:
+            await asyncio.sleep(timeout)
+            # Read before `_lock` so the checks and release below cannot suspend.
+            task = await self._task_manager.get_task()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception(
+                'ActiveTask[%s]: Idle release check failed', self._task_id
+            )
+            return
+        async with self._lock:
+            if (
+                task is None
+                or task.status.state not in INTERRUPTED_TASK_STATES
+                or self._is_finished.is_set()
+                # The consumer holds one reference; more means subscribers.
+                or self._reference_count != 1
+                or self._request_lock.locked()
+                or not self._request_queue.empty()
+            ):
+                return
+            logger.debug(
+                'ActiveTask[%s]: Releasing task parked in %s',
+                self._task_id,
+                TaskState.Name(task.status.state),
+            )
+            self._is_finished.set()
+            self._request_queue.shutdown(immediate=True)
+
+    async def _maybe_cleanup(self) -> None:
+        """Triggers cleanup if task is finished and has no subscribers.
+
+        Concurrency Guarantee:
+        Protected by `_lock` to prevent race conditions where a new subscriber
+        attaches at the exact moment the task decides to garbage collect itself.
+        """
+        async with self._lock:
+            logger.debug(
+                'Cleanup[%s]: Subscribers count: %d is_finished: %s',
+                self._task_id,
+                self._reference_count,
+                self._is_finished.is_set(),
+            )
+
+            if (
+                self._is_finished.is_set()
+                and self._reference_count == 0
+                and self._on_cleanup
+            ):
+                logger.debug('Cleanup[%s]: Triggering cleanup', self._task_id)
+                self._on_cleanup(self)
+
+    async def _mark_task_as_failed(self, exception: Exception) -> Task | None:
+        logger.debug('Marking task %s as failed: %s', self._task_id, exception)
+        task = None
+        if self._task_created.is_set():
+            try:
+                task = await self._task_manager.get_task()
+                if (
+                    task is not None
+                    and task.status.state not in TERMINAL_TASK_STATES
+                ):
+                    await self._event_queue_agent.enqueue_event(
+                        TaskStatusUpdateEvent(
+                            task_id=task.id,
+                            context_id=task.context_id,
+                            status=TaskStatus(
+                                state=TaskState.TASK_STATE_FAILED,
+                            ),
+                        )
+                    )
+            except QueueShutDown:
+                pass
+        return task
+
+    @property
+    def task_created(self) -> bool:
+        """Whether a task exists, so ``get_task()`` will not block."""
+        return self._task_created.is_set()
+
+    async def get_task(self) -> Task:
+        """Get task from db."""
+        await self._task_created.wait()
+        task = await self._task_manager.get_task()
+        if not task:
+            raise RuntimeError('Task should have been created')
+        return task
diff --git a/src/a2a/server/agent_execution/active_task_registry.py b/src/a2a/server/agent_execution/active_task_registry.py
new file mode 100644
index 000000000..a5350bbf4
--- /dev/null
+++ b/src/a2a/server/agent_execution/active_task_registry.py
@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from a2a.plugins.manager import PluginManager
+    from a2a.server.agent_execution.agent_executor import AgentExecutor
+    from a2a.server.cluster.event_stream import TaskEventStream
+    from a2a.server.cluster.task_store import VersionedTaskStore
+    from a2a.server.context import ServerCallContext
+    from a2a.server.tasks.push_notification_sender import PushNotificationSender
+    from a2a.server.tasks.task_store import TaskStore
+    from a2a.types.a2a_pb2 import Message
+
+from a2a.server.agent_execution.active_task import ActiveTask
+from a2a.server.cluster.task_store import StoredTask
+from a2a.server.tasks.task_manager import TaskManager
+from a2a.utils.errors import TaskNotFoundError
+
+
+logger = logging.getLogger(__name__)
+
+
+class ActiveTaskRegistry:
+    """A registry for active ActiveTask instances."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        agent_executor: AgentExecutor,
+        task_store: TaskStore | VersionedTaskStore,
+        push_sender: PushNotificationSender | None = None,
+        event_stream: TaskEventStream | None = None,
+        interrupted_task_timeout: float | None = None,
+        plugins: PluginManager | None = None,
+    ):
+        self._agent_executor = agent_executor
+        self._plugins = plugins
+        self._task_store = task_store
+        self._push_sender = push_sender
+        self._interrupted_task_timeout = interrupted_task_timeout
+        self._event_stream = event_stream
+        self._active_tasks: dict[str, ActiveTask] = {}
+        self._lock = threading.RLock()
+        self._cleanup_tasks: set[asyncio.Task[None]] = set()
+        self._closed = False
+
+    async def get_or_create(
+        self,
+        task_id: str,
+        call_context: ServerCallContext,
+        context_id: str | None = None,
+        create_task_if_missing: bool = False,
+        initial_message: Message | None = None,
+    ) -> ActiveTask:
+        """Retrieves an existing ActiveTask or creates a new one."""
+        with self._lock:
+            if self._closed:
+                raise RuntimeError('ActiveTaskRegistry is closed')
+            existing = self._active_tasks.get(task_id)
+            if existing is not None and existing.is_finished:
+                # Its removal runs asynchronously, so replace it instead.
+                existing = None
+            if existing is not None:
+                # A request is about to use it, so it must not be released.
+                existing.cancel_idle_release()
+            if existing is None:
+                task_manager = TaskManager(
+                    task_id=task_id,
+                    context_id=context_id,
+                    task_store=self._task_store,
+                    initial_message=initial_message,
+                    context=call_context,
+                    plugins=self._plugins,
+                )
+
+                active_task = ActiveTask(
+                    agent_executor=self._agent_executor,
+                    task_id=task_id,
+                    task_manager=task_manager,
+                    push_sender=self._push_sender,
+                    on_cleanup=self._on_active_task_cleanup,
+                    event_stream=self._event_stream,
+                    interrupted_task_timeout=self._interrupted_task_timeout,
+                )
+                self._active_tasks[task_id] = active_task
+
+        if existing is not None:
+            # Owner-aware guard on the cache-hit path. The miss path below is
+            # owner-scoped by ActiveTask.start(), which reads through the task
+            # store with call_context and raises TaskNotFoundError when the
+            # task is not owned and create_task_if_missing is false. A cache
+            # hit returned before that check, so resolving a live task by id
+            # was an unauthenticated lookup (issue #1159, CWE-639): every
+            # call site had to guard first. Enforce it here instead, so the
+            # hit path is symmetric with the miss path and no future caller
+            # can reintroduce the gap. Skipped when create_task_if_missing is
+            # set, which is the on_message_send create path establishing
+            # ownership. Masked as not-found so existence is not leaked. Done
+            # outside _lock because the store read is I/O and the miss-path
+            # check runs outside the lock too.
+            if not create_task_if_missing:
+                existing_task = await self._task_store.get(
+                    task_id, call_context
+                )
+                # A VersionedTaskStore returns a StoredTask; a plain store
+                # returns the task (or None). Normalize before the check.
+                if isinstance(existing_task, StoredTask):
+                    existing_task = existing_task.task
+                if not existing_task:
+                    existing.schedule_idle_release()
+                    raise TaskNotFoundError
+            return existing
+
+        await active_task.start(
+            call_context=call_context,
+            create_task_if_missing=create_task_if_missing,
+        )
+        return active_task
+
+    def _on_active_task_cleanup(self, active_task: ActiveTask) -> None:
+        """Called by ActiveTask when it's finished and has no subscribers."""
+        logger.debug('Active task %s cleanup scheduled', active_task.task_id)
+        task = asyncio.create_task(self._remove_task(active_task))
+        self._cleanup_tasks.add(task)
+        task.add_done_callback(self._cleanup_tasks.discard)
+
+    async def _remove_task(self, active_task: ActiveTask) -> None:
+        task_id = active_task.task_id
+        with self._lock:
+            # Only remove this instance; it may already have been replaced.
+            if self._active_tasks.get(task_id) is active_task:
+                del self._active_tasks[task_id]
+                logger.debug(
+                    'Removed active task for %s from registry', task_id
+                )
+
+    async def get(self, task_id: str) -> ActiveTask | None:
+        """Retrieves an existing task."""
+        with self._lock:
+            return self._active_tasks.get(task_id)
+
+    async def aclose(self) -> None:
+        """Closes the registry and drains all active tasks.
+
+        Marks the registry closed so ``get_or_create`` refuses new work, then
+        force-closes every registered ``ActiveTask`` and awaits the in-flight
+        ``_remove_task`` cleanup tasks they schedule, so no SDK-owned
+        ``asyncio.Task`` is left pending at event-loop shutdown. Safe to call
+        multiple times.
+
+        The close flag is set and the active-task snapshot is taken under
+        ``_lock``, then the lock is released before awaiting the drain. Marking
+        closed under the same lock prevents a concurrent ``get_or_create`` from
+        registering a task that the drain would miss.
+        """
+        with self._lock:
+            self._closed = True
+            active_tasks = list(self._active_tasks.values())
+
+        if active_tasks:
+            results = await asyncio.gather(
+                *(task.aclose() for task in active_tasks),
+                return_exceptions=True,
+            )
+            for result in results:
+                if isinstance(result, Exception):
+                    logger.error('Error draining active task', exc_info=result)
+
+        cleanup_tasks = list(self._cleanup_tasks)
+        if cleanup_tasks:
+            await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+
+        with self._lock:
+            self._active_tasks.clear()
diff --git a/src/a2a/server/agent_execution/agent_executor.py b/src/a2a/server/agent_execution/agent_executor.py
index bbf82a8bb..1c3866047 100644
--- a/src/a2a/server/agent_execution/agent_executor.py
+++ b/src/a2a/server/agent_execution/agent_executor.py
@@ -1,16 +1,82 @@
 from abc import ABC, abstractmethod
 
 from a2a.server.agent_execution.context import RequestContext
-from a2a.server.events.event_queue import EventQueue
+from a2a.server.events.event_queue_v2 import EventQueue
 
 
 class AgentExecutor(ABC):
-    """Agent Executor interface."""
+    """Agent Executor interface.
+
+    Implementations of this interface contain the core logic of the agent,
+    executing tasks based on requests and publishing updates to an event queue.
+    """
 
     @abstractmethod
-    async def execute(self, context: RequestContext, event_queue: EventQueue):
-        pass
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Execute the agent's logic for a given request context.
+
+        The agent should read necessary information from the `context` and
+        publish `Task` or `Message` events, or `TaskStatusUpdateEvent` /
+        `TaskArtifactUpdateEvent` to the `event_queue`. This method should
+        return once the agent's execution for this request is complete or
+        yields control (e.g., enters an input-required state).
+
+        Request Lifecycle & AgentExecutor Responsibilities:
+        - **Concurrency**: The framework guarantees single execution per request;
+          `execute()` will not be called concurrently for the same request context.
+        - **Exception Handling**: Unhandled exceptions raised by `execute()` will be
+          caught by the framework and result in the task transitioning to
+          `TaskState.TASK_STATE_ERROR`.
+        - **Post-Completion**: Once `execute()` completes (returns or raises), the
+          executor must not access the `context` or `event_queue` anymore.
+        - **Terminal States**: Before completing the call normally, the executor
+          SHOULD publish a `TaskStatusUpdateEvent` to transition the task to a
+          terminal state (e.g., `TASK_STATE_COMPLETED`) or an interrupted state
+          (`TASK_STATE_INPUT_REQUIRED` or `TASK_STATE_AUTH_REQUIRED`).
+        - **Interrupted Workflows**:
+            - `TASK_STATE_INPUT_REQUIRED`: The executor publishes a `TaskStatusUpdateEvent` with
+              `TaskState.TASK_STATE_INPUT_REQUIRED` and returns to yield control.
+              The request will resume once user input is provided.
+            - `TASK_STATE_AUTH_REQUIRED`: There are in-bound and out-of-bound auth models.
+              In both scenarios, the agent publishes a `TaskStatusUpdateEvent` with
+              `TaskState.TASK_STATE_AUTH_REQUIRED`.
+                - In-bound: The agent should return from `execute()`. The framework will
+                  call `execute()` again once the user response is received.
+                - Out-of-bound: The agent should not return from `execute()`. It should wait
+                  for the out-of-band auth provider to complete the authentication and then
+                  continue execution.
+
+        - **Cancellation Workflow**: When a cancellation request is received, the
+          async task running `execute()` is cancelled (raising an `asyncio.CancelledError`),
+          and `cancel()` is explicitly called by the framework.
+
+        Allowed Workflows:
+        - Immediate response: Enqueue a SINGLE `Message` object.
+        - Asynchronous/Long-running: Enqueue a `Task` object, perform work, and emit
+          multiple `TaskStatusUpdateEvent` / `TaskArtifactUpdateEvent` objects over time.
+
+        Note that the framework waits with response to the send_message request with
+        `return_immediately=True` parameter until the first event (Message or Task)
+        is enqueued by AgentExecutor.
+
+        Args:
+            context: The request context containing the message, task ID, etc.
+            event_queue: The queue to publish events to.
+        """
 
     @abstractmethod
-    async def cancel(self, context: RequestContext, event_queue: EventQueue):
-        pass
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Request the agent to cancel an ongoing task.
+
+        The agent should attempt to stop the task identified by the task_id
+        in the context and publish a `TaskStatusUpdateEvent` with state
+        `TaskState.TASK_STATE_CANCELED` to the `event_queue`.
+
+        Args:
+            context: The request context containing the task ID to cancel.
+            event_queue: The queue to publish the cancellation status update to.
+        """
diff --git a/src/a2a/server/agent_execution/base_agent_executor.py b/src/a2a/server/agent_execution/base_agent_executor.py
deleted file mode 100644
index 13f228b16..000000000
--- a/src/a2a/server/agent_execution/base_agent_executor.py
+++ /dev/null
@@ -1,48 +0,0 @@
-from a2a.server.agent_execution.agent_executor import AgentExecutor
-from a2a.server.events.event_queue import EventQueue
-from a2a.types import (
-    A2AError,
-    CancelTaskRequest,
-    SendMessageRequest,
-    SendStreamingMessageRequest,
-    Task,
-    TaskResubscriptionRequest,
-    UnsupportedOperationError,
-)
-
-
-class BaseAgentExecutor(AgentExecutor):
-    """Base AgentExecutor which returns unsupported operation error."""
-
-    async def on_message_send(
-        self,
-        request: SendMessageRequest,
-        event_queue: EventQueue,
-        task: Task | None,
-    ) -> None:
-        """Handler for 'message/send' requests."""
-        event_queue.enqueue_event(A2AError(UnsupportedOperationError()))
-
-    async def on_message_stream(
-        self,
-        request: SendStreamingMessageRequest,
-        event_queue: EventQueue,
-        task: Task | None,
-    ) -> None:
-        """Handler for 'message/stream' requests."""
-        event_queue.enqueue_event(A2AError(UnsupportedOperationError()))
-
-    async def on_cancel(
-        self, request: CancelTaskRequest, event_queue: EventQueue, task: Task
-    ) -> None:
-        """Handler for 'tasks/cancel' requests."""
-        event_queue.enqueue_event(A2AError(UnsupportedOperationError()))
-
-    async def on_resubscribe(
-        self,
-        request: TaskResubscriptionRequest,
-        event_queue: EventQueue,
-        task: Task,
-    ) -> None:
-        """Handler for 'tasks/resubscribe' requests."""
-        event_queue.enqueue_event(A2AError(UnsupportedOperationError()))
diff --git a/src/a2a/server/agent_execution/context.py b/src/a2a/server/agent_execution/context.py
index 870c5f8e1..5d1ca5f16 100644
--- a/src/a2a/server/agent_execution/context.py
+++ b/src/a2a/server/agent_execution/context.py
@@ -1,98 +1,196 @@
-import uuid
+from typing import Any
 
-from a2a.types import (
-    InvalidParamsError,
+from google.protobuf import json_format
+
+from a2a.helpers.proto_helpers import get_message_text
+from a2a.server.context import ServerCallContext
+from a2a.server.id_generator import (
+    IDGenerator,
+    IDGeneratorContext,
+    UUIDGenerator,
+)
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
     Message,
-    MessageSendParams,
+    SendMessageConfiguration,
+    SendMessageRequest,
     Task,
 )
-from a2a.utils import get_message_text
-from a2a.utils.errors import ServerError
+from a2a.utils.errors import InvalidParamsError
 
 
 class RequestContext:
-    """Request Context."""
+    """Request Context.
+
+    Holds information about the current request being processed by the server,
+    including the incoming message, task and context identifiers, and related
+    tasks.
+    """
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
-        request: MessageSendParams | None = None,
+        call_context: ServerCallContext,
+        request: SendMessageRequest | CancelTaskRequest | None = None,
         task_id: str | None = None,
         context_id: str | None = None,
         task: Task | None = None,
         related_tasks: list[Task] | None = None,
-    ):
+        task_id_generator: IDGenerator | None = None,
+        context_id_generator: IDGenerator | None = None,
+    ) -> None:
+        """Initializes the RequestContext.
+
+        Args:
+            call_context: The server call context associated with this request.
+            request: The incoming `SendMessageRequest` or `CancelTaskRequest` payload.
+            task_id: The ID of the task explicitly provided in the request or path.
+            context_id: The ID of the context explicitly provided in the request or path.
+            task: The existing `Task` object retrieved from the store, if any.
+            related_tasks: A list of other tasks related to the current request (e.g., for tool use).
+            task_id_generator: ID generator for new task IDs. Defaults to UUID generator.
+            context_id_generator: ID generator for new context IDs. Defaults to UUID generator.
+        """
         if related_tasks is None:
             related_tasks = []
-        self._params = request
+        self._call_context = call_context
+        self._request: SendMessageRequest | CancelTaskRequest | None = request
+        self._params: SendMessageRequest | None = (
+            None if isinstance(request, CancelTaskRequest) else request
+        )
         self._task_id = task_id
         self._context_id = context_id
         self._current_task = task
         self._related_tasks = related_tasks
+        self._task_id_generator = (
+            task_id_generator if task_id_generator else UUIDGenerator()
+        )
+        self._context_id_generator = (
+            context_id_generator if context_id_generator else UUIDGenerator()
+        )
         # If the task id and context id were provided, make sure they
         # match the request. Otherwise, create them
         if self._params:
             if task_id:
-                self._params.message.taskId = task_id
+                self._params.message.task_id = task_id
                 if task and task.id != task_id:
-                    raise ServerError(InvalidParamsError(message='bad task id'))
+                    raise InvalidParamsError(message='bad task id')
             else:
                 self._check_or_generate_task_id()
             if context_id:
-                self._params.message.contextId = context_id
-                if task and task.contextId != context_id:
-                    raise ServerError(
-                        InvalidParamsError(message='bad context id')
-                    )
+                self._params.message.context_id = context_id
+                if task and task.context_id != context_id:
+                    raise InvalidParamsError(message='bad context id')
             else:
                 self._check_or_generate_context_id()
 
-    def get_user_input(self, delimiter='\n') -> str:
+    def get_user_input(self, delimiter: str = '\n') -> str:
+        """Extracts text content from the user's message parts.
+
+        Args:
+            delimiter: The string to use when joining multiple text parts.
+
+        Returns:
+            A single string containing all text content from the user message,
+            joined by the specified delimiter. Returns an empty string if no
+            user message is present or if it contains no text parts.
+        """
         if not self._params:
             return ''
 
         return get_message_text(self._params.message, delimiter)
 
-    def attach_related_task(self, task: Task):
+    def attach_related_task(self, task: Task) -> None:
+        """Attaches a related task to the context.
+
+        This is useful for scenarios like tool execution where a new task
+        might be spawned.
+
+        Args:
+            task: The `Task` object to attach.
+        """
         self._related_tasks.append(task)
 
     @property
     def message(self) -> Message | None:
+        """The incoming `Message` object from the request, if available."""
         return self._params.message if self._params else None
 
     @property
     def related_tasks(self) -> list[Task]:
+        """A list of tasks related to the current request."""
         return self._related_tasks
 
     @property
     def current_task(self) -> Task | None:
+        """The current `Task` object being processed."""
         return self._current_task
 
     @current_task.setter
-    def current_task(self, task: Task) -> None:
+    def current_task(self, task: Task | None) -> None:
+        """Sets the current task object."""
         self._current_task = task
 
     @property
     def task_id(self) -> str | None:
+        """The ID of the task associated with this context."""
         return self._task_id
 
     @property
     def context_id(self) -> str | None:
+        """The ID of the conversation context associated with this task."""
         return self._context_id
 
+    @property
+    def configuration(self) -> SendMessageConfiguration | None:
+        """The `SendMessageConfiguration` from the request, if available."""
+        return self._params.configuration if self._params else None
+
+    @property
+    def call_context(self) -> ServerCallContext:
+        """The server call context associated with this request."""
+        return self._call_context
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        """Metadata associated with the request, if available."""
+        if self._request:
+            # MessageToDict recurses into nested Struct/ListValue fields;
+            # dict would leak raw protobuf objects to callers.
+            return json_format.MessageToDict(self._request.metadata)
+        return {}
+
+    @property
+    def tenant(self) -> str:
+        """The tenant associated with this request."""
+        return self._call_context.tenant
+
+    @property
+    def requested_extensions(self) -> set[str]:
+        """Extensions that the client requested for this interaction."""
+        return self._call_context.requested_extensions
+
     def _check_or_generate_task_id(self) -> None:
+        """Ensures a task ID is present, generating one if necessary."""
         if not self._params:
             return
 
-        if not self._task_id and not self._params.message.taskId:
-            self._params.message.taskId = str(uuid.uuid4())
-        if self._params.message.taskId:
-            self._task_id = self._params.message.taskId
+        if not self._task_id and not self._params.message.task_id:
+            self._params.message.task_id = self._task_id_generator.generate(
+                IDGeneratorContext(context_id=self._context_id)
+            )
+        if self._params.message.task_id:
+            self._task_id = self._params.message.task_id
 
     def _check_or_generate_context_id(self) -> None:
+        """Ensures a context ID is present, generating one if necessary."""
         if not self._params:
             return
 
-        if not self._context_id and not self._params.message.contextId:
-            self._params.message.contextId = str(uuid.uuid4())
-        if self._params.message.contextId:
-            self._context_id = self._params.message.contextId
+        if not self._context_id and not self._params.message.context_id:
+            self._params.message.context_id = (
+                self._context_id_generator.generate(
+                    IDGeneratorContext(task_id=self._task_id)
+                )
+            )
+        if self._params.message.context_id:
+            self._context_id = self._params.message.context_id
diff --git a/src/a2a/server/agent_execution/plugin_agent_executor.py b/src/a2a/server/agent_execution/plugin_agent_executor.py
new file mode 100644
index 000000000..198611230
--- /dev/null
+++ b/src/a2a/server/agent_execution/plugin_agent_executor.py
@@ -0,0 +1,83 @@
+"""Runs `ExecutionPlugin` hooks around an `AgentExecutor`."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.events.event_queue import EventQueue
+
+
+if TYPE_CHECKING:
+    from a2a.plugins.manager import PluginManager
+    from a2a.server.agent_execution.context import RequestContext
+    from a2a.server.events.event_queue import Event
+
+
+class PluginEventQueue(EventQueue):
+    """Calls `on_execution_event` for each event the agent enqueues.
+
+    Wraps the queue passed to `AgentExecutor.execute`. Events the SDK enqueues
+    on the underlying queue itself bypass the wrapper and are not reported.
+    """
+
+    def __init__(
+        self,
+        inner: EventQueue,
+        plugins: PluginManager,
+        request_context: RequestContext,
+    ) -> None:
+        self._inner = inner
+        self._plugins = plugins
+        self._request_context = request_context
+
+    async def enqueue_event(self, event: Event) -> None:
+        """Reports the event to plugins, then enqueues it."""
+        await self._plugins.on_execution_event(self._request_context, event)
+        await self._inner.enqueue_event(event)
+
+    def __getattr__(self, name: str) -> Any:
+        """Forwards other attributes to the wrapped queue.
+
+        Keeps executors working that rely on the concrete queue type.
+        """
+        if name == '_inner':
+            raise AttributeError(name)
+        return getattr(self._inner, name)
+
+
+class PluginAgentExecutor(AgentExecutor):
+    """Runs `before_execution` / `after_execution` around ``execute``."""
+
+    def __init__(self, inner: AgentExecutor, plugins: PluginManager) -> None:
+        self._inner = inner
+        self._plugins = plugins
+
+    @property
+    def inner(self) -> AgentExecutor:
+        """The wrapped executor."""
+        return self._inner
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Runs the wrapped executor with execution hooks."""
+        # If a before-hook raises, the manager unwinds the plugins that ran
+        # and the exception fails the execution.
+        await self._plugins.before_execution(context)
+        error: BaseException | None = None
+        try:
+            await self._inner.execute(
+                context, PluginEventQueue(event_queue, self._plugins, context)
+            )
+        except Exception as e:
+            error = e
+            raise
+        finally:
+            await self._plugins.after_execution(context, error)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Delegates to the wrapped executor without hooks."""
+        await self._inner.cancel(context, event_queue)
diff --git a/src/a2a/server/agent_execution/request_context_builder.py b/src/a2a/server/agent_execution/request_context_builder.py
new file mode 100644
index 000000000..cab82b401
--- /dev/null
+++ b/src/a2a/server/agent_execution/request_context_builder.py
@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+from a2a.server.agent_execution import RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.types.a2a_pb2 import SendMessageRequest, Task
+
+
+class RequestContextBuilder(ABC):
+    """Builds request context to be supplied to agent executor."""
+
+    @abstractmethod
+    async def build(
+        self,
+        context: ServerCallContext,
+        params: SendMessageRequest | None = None,
+        task_id: str | None = None,
+        context_id: str | None = None,
+        task: Task | None = None,
+    ) -> RequestContext:
+        pass
diff --git a/src/a2a/server/agent_execution/simple_request_context_builder.py b/src/a2a/server/agent_execution/simple_request_context_builder.py
new file mode 100644
index 000000000..5f2b7c521
--- /dev/null
+++ b/src/a2a/server/agent_execution/simple_request_context_builder.py
@@ -0,0 +1,86 @@
+import asyncio
+
+from a2a.server.agent_execution import RequestContext, RequestContextBuilder
+from a2a.server.context import ServerCallContext
+from a2a.server.id_generator import IDGenerator
+from a2a.server.tasks import TaskStore
+from a2a.types.a2a_pb2 import SendMessageRequest, Task
+
+
+class SimpleRequestContextBuilder(RequestContextBuilder):
+    """Builds request context and populates referred tasks."""
+
+    def __init__(
+        self,
+        should_populate_referred_tasks: bool = False,
+        task_store: TaskStore | None = None,
+        task_id_generator: IDGenerator | None = None,
+        context_id_generator: IDGenerator | None = None,
+    ) -> None:
+        """Initializes the SimpleRequestContextBuilder.
+
+        Args:
+            should_populate_referred_tasks: If True, the builder will fetch tasks
+                referenced in `params.message.reference_task_ids` and populate the
+                `related_tasks` field in the RequestContext. Defaults to False.
+            task_store: The TaskStore instance to use for fetching referred tasks.
+                Required if `should_populate_referred_tasks` is True.
+            task_id_generator: ID generator for new task IDs. Defaults to None.
+            context_id_generator: ID generator for new context IDs. Defaults to None.
+        """
+        self._task_store = task_store
+        self._should_populate_referred_tasks = should_populate_referred_tasks
+        self._task_id_generator = task_id_generator
+        self._context_id_generator = context_id_generator
+
+    async def build(
+        self,
+        context: ServerCallContext,
+        params: SendMessageRequest | None = None,
+        task_id: str | None = None,
+        context_id: str | None = None,
+        task: Task | None = None,
+    ) -> RequestContext:
+        """Builds the request context for an agent execution.
+
+        This method assembles the RequestContext object. If the builder was
+        initialized with `should_populate_referred_tasks=True`, it fetches all tasks
+        referenced in `params.message.reference_task_ids` from the `task_store`.
+
+        Args:
+            context: The server call context, containing metadata about the call.
+            params: The parameters of the incoming message send request.
+            task_id: The ID of the task being executed.
+            context_id: The ID of the current execution context.
+            task: The primary task object associated with the request.
+
+        Returns:
+            An instance of RequestContext populated with the provided information
+            and potentially a list of related tasks.
+        """
+        related_tasks: list[Task] | None = None
+
+        if (
+            self._task_store
+            and self._should_populate_referred_tasks
+            and params
+            and params.message.reference_task_ids
+        ):
+            tasks = await asyncio.gather(
+                *[
+                    self._task_store.get(task_id, context)
+                    for task_id in params.message.reference_task_ids
+                ]
+            )
+            related_tasks = [x for x in tasks if x is not None]
+
+        return RequestContext(
+            call_context=context,
+            request=params,
+            task_id=task_id,
+            context_id=context_id,
+            task=task,
+            related_tasks=related_tasks,
+            task_id_generator=self._task_id_generator,
+            context_id_generator=self._context_id_generator,
+        )
diff --git a/src/a2a/server/apps/__init__.py b/src/a2a/server/apps/__init__.py
deleted file mode 100644
index 76b6e4652..000000000
--- a/src/a2a/server/apps/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from a2a.server.apps.http_app import HttpApp
-from a2a.server.apps.starlette_app import A2AStarletteApplication
-
-
-__all__ = ['A2AStarletteApplication', 'HttpApp']
diff --git a/src/a2a/server/apps/http_app.py b/src/a2a/server/apps/http_app.py
deleted file mode 100644
index a04cb2476..000000000
--- a/src/a2a/server/apps/http_app.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-from starlette.applications import Starlette
-
-
-class HttpApp(ABC):
-    """A2A Server application interface."""
-
-    @abstractmethod
-    def build(self, **kwargs: Any) -> Starlette:
-        pass
diff --git a/src/a2a/server/apps/starlette_app.py b/src/a2a/server/apps/starlette_app.py
deleted file mode 100644
index 5bbdcced9..000000000
--- a/src/a2a/server/apps/starlette_app.py
+++ /dev/null
@@ -1,306 +0,0 @@
-import json
-import logging
-import traceback
-
-from collections.abc import AsyncGenerator
-from typing import Any
-
-from pydantic import ValidationError
-from sse_starlette.sse import EventSourceResponse
-from starlette.applications import Starlette
-from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
-from starlette.routing import Route
-
-from a2a.server.request_handlers.jsonrpc_handler import (
-    JSONRPCHandler,
-    RequestHandler,
-)
-from a2a.types import (
-    A2AError,
-    A2ARequest,
-    AgentCard,
-    CancelTaskRequest,
-    GetTaskPushNotificationConfigRequest,
-    GetTaskRequest,
-    InternalError,
-    InvalidRequestError,
-    JSONParseError,
-    JSONRPCError,
-    JSONRPCErrorResponse,
-    JSONRPCResponse,
-    SendMessageRequest,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
-    SetTaskPushNotificationConfigRequest,
-    TaskResubscriptionRequest,
-    UnsupportedOperationError,
-)
-from a2a.utils.errors import MethodNotImplementedError
-
-
-logger = logging.getLogger(__name__)
-
-
-class A2AStarletteApplication:
-    """A Starlette application implementing the A2A protocol server endpoints.
-
-    Handles incoming JSON-RPC requests, routes them to the appropriate
-    handler methods, and manages response generation including Server-Sent Events
-    (SSE).
-    """
-
-    def __init__(self, agent_card: AgentCard, http_handler: RequestHandler):
-        """Initializes the A2AApplication.
-
-        Args:
-            agent_card: The AgentCard describing the agent's capabilities.
-            http_handler: The handler instance responsible for processing A2A
-              requests via http.
-        """
-        self.agent_card = agent_card
-        self.handler = JSONRPCHandler(
-            agent_card=agent_card, request_handler=http_handler
-        )
-
-    def _generate_error_response(
-        self, request_id: str | int | None, error: JSONRPCError | A2AError
-    ) -> JSONResponse:
-        """Creates a JSONResponse for a JSON-RPC error."""
-        error_resp = JSONRPCErrorResponse(
-            id=request_id,
-            error=error if isinstance(error, JSONRPCError) else error.root,
-        )
-
-        log_level = (
-            logging.ERROR
-            if not isinstance(error, A2AError)
-            or isinstance(error.root, InternalError)
-            else logging.WARNING
-        )
-        logger.log(
-            log_level,
-            f'Request Error (ID: {request_id}: '
-            f"Code={error_resp.error.code}, Message='{error_resp.error.message}'"
-            f'{", Data=" + str(error_resp.error.data) if hasattr(error, "data") and error_resp.error.data else ""}',
-        )
-        return JSONResponse(
-            error_resp.model_dump(mode='json', exclude_none=True),
-            status_code=200,
-        )
-
-    async def _handle_requests(self, request: Request) -> Response:
-        """Handles incoming POST requests to the main A2A endpoint.
-
-        Parses the request body as JSON, validates it against A2A request types,
-        dispatches it to the appropriate handler method, and returns the response.
-        Handles JSON parsing errors, validation errors, and other exceptions,
-        returning appropriate JSON-RPC error responses.
-        """
-        request_id = None
-        body = None
-
-        try:
-            body = await request.json()
-            a2a_request = A2ARequest.model_validate(body)
-
-            request_id = a2a_request.root.id
-            request_obj = a2a_request.root
-
-            if isinstance(
-                request_obj,
-                TaskResubscriptionRequest | SendStreamingMessageRequest,
-            ):
-                return await self._process_streaming_request(
-                    request_id, a2a_request
-                )
-
-            return await self._process_non_streaming_request(
-                request_id, a2a_request
-            )
-        except MethodNotImplementedError:
-            traceback.print_exc()
-            return self._generate_error_response(
-                request_id, A2AError(root=UnsupportedOperationError())
-            )
-        except json.decoder.JSONDecodeError as e:
-            traceback.print_exc()
-            return self._generate_error_response(
-                None, A2AError(root=JSONParseError(message=str(e)))
-            )
-        except ValidationError as e:
-            traceback.print_exc()
-            return self._generate_error_response(
-                request_id,
-                A2AError(root=InvalidRequestError(data=json.loads(e.json()))),
-            )
-        except Exception as e:
-            logger.error(f'Unhandled exception: {e}')
-            traceback.print_exc()
-            return self._generate_error_response(
-                request_id, A2AError(root=InternalError(message=str(e)))
-            )
-
-    async def _process_streaming_request(
-        self, request_id: str | int | None, a2a_request: A2ARequest
-    ) -> Response:
-        """Processes streaming requests.
-
-        Args:
-            request_id: The ID of the request.
-            a2a_request: The validated A2ARequest object.
-        """
-        request_obj = a2a_request.root
-        handler_result: Any = None
-        if isinstance(
-            request_obj,
-            SendStreamingMessageRequest,
-        ):
-            handler_result = self.handler.on_message_send_stream(request_obj)
-        elif isinstance(request_obj, TaskResubscriptionRequest):
-            handler_result = self.handler.on_resubscribe_to_task(request_obj)
-
-        return self._create_response(handler_result)
-
-    async def _process_non_streaming_request(
-        self, request_id: str | int | None, a2a_request: A2ARequest
-    ) -> Response:
-        """Processes non-streaming requests.
-
-        Args:
-            request_id: The ID of the request.
-            a2a_request: The validated A2ARequest object.
-        """
-        request_obj = a2a_request.root
-        handler_result: Any = None
-        match request_obj:
-            case SendMessageRequest():
-                handler_result = await self.handler.on_message_send(request_obj)
-            case CancelTaskRequest():
-                handler_result = await self.handler.on_cancel_task(request_obj)
-            case GetTaskRequest():
-                handler_result = await self.handler.on_get_task(request_obj)
-            case SetTaskPushNotificationConfigRequest():
-                handler_result = await self.handler.set_push_notification(
-                    request_obj
-                )
-            case GetTaskPushNotificationConfigRequest():
-                handler_result = await self.handler.get_push_notification(
-                    request_obj
-                )
-            case _:
-                logger.error(
-                    f'Unhandled validated request type: {type(request_obj)}'
-                )
-                error = UnsupportedOperationError(
-                    message=f'Request type {type(request_obj).__name__} is unknown.'
-                )
-                handler_result = JSONRPCErrorResponse(
-                    id=request_id, error=error
-                )
-
-        return self._create_response(handler_result)
-
-    def _create_response(
-        self,
-        handler_result: (
-            AsyncGenerator[SendStreamingMessageResponse, None]
-            | JSONRPCErrorResponse
-            | JSONRPCResponse
-        ),
-    ) -> Response:
-        """Creates a Starlette Response based on the result from the request handler.
-
-        Handles:
-        - AsyncGenerator for Server-Sent Events (SSE).
-        - JSONRPCErrorResponse for explicit errors returned by handlers.
-        - Pydantic RootModels (like GetTaskResponse) containing success or error
-        payloads.
-        - Unexpected types by returning an InternalError.
-
-        Args:
-            handler_result: AsyncGenerator of SendStreamingMessageResponse
-
-        Returns:
-            A Starlette JSONResponse or EventSourceResponse.
-        """
-        if isinstance(handler_result, AsyncGenerator):
-            # Result is a stream of SendStreamingMessageResponse objects
-            async def event_generator(
-                stream: AsyncGenerator[SendStreamingMessageResponse, None],
-            ) -> AsyncGenerator[dict[str, str], None]:
-                async for item in stream:
-                    yield {'data': item.root.model_dump_json(exclude_none=True)}
-
-            return EventSourceResponse(event_generator(handler_result))
-        if isinstance(handler_result, JSONRPCErrorResponse):
-            return JSONResponse(
-                handler_result.model_dump(
-                    mode='json',
-                    exclude_none=True,
-                )
-            )
-
-        return JSONResponse(
-            handler_result.root.model_dump(mode='json', exclude_none=True)
-        )
-
-    async def _handle_get_agent_card(self, request: Request) -> JSONResponse:
-        """Handles GET requests for the agent card."""
-        return JSONResponse(
-            self.agent_card.model_dump(mode='json', exclude_none=True)
-        )
-
-    def routes(
-        self,
-        agent_card_url: str = '/.well-known/agent.json',
-        rpc_url: str = '/',
-    ) -> list[Route]:
-        """Returns the Starlette Routes for handling A2A requests.
-
-        Args:
-            agent_card_url: The URL for the agent card endpoint.
-            rpc_url: The URL for the A2A JSON-RPC endpoint
-
-        Returns:
-            The Starlette Routes serving A2A requests.
-        """
-        return [
-            Route(
-                rpc_url,
-                self._handle_requests,
-                methods=['POST'],
-                name='a2a_handler',
-            ),
-            Route(
-                agent_card_url,
-                self._handle_get_agent_card,
-                methods=['GET'],
-                name='agent_card',
-            ),
-        ]
-
-    def build(
-        self,
-        agent_card_url: str = '/.well-known/agent.json',
-        rpc_url: str = '/',
-        **kwargs: Any,
-    ) -> Starlette:
-        """Builds and returns the Starlette application instance.
-
-        Args:
-            agent_card_url: The URL for the agent card endpoint.
-            rpc_url: The URL for the A2A JSON-RPC endpoint
-            **kwargs: Additional keyword arguments to pass to the Starlette
-              constructor.
-
-        Returns:
-            A configured Starlette application instance.
-        """
-        routes = self.routes(agent_card_url, rpc_url)
-        if 'routes' in kwargs:
-            kwargs['routes'] += routes
-        else:
-            kwargs['routes'] = routes
-
-        return Starlette(**kwargs)
diff --git a/src/a2a/server/cluster/__init__.py b/src/a2a/server/cluster/__init__.py
new file mode 100644
index 000000000..f7c4f1ac9
--- /dev/null
+++ b/src/a2a/server/cluster/__init__.py
@@ -0,0 +1,57 @@
+import logging
+
+from a2a.server.cluster.event_stream import TaskEventStream, VersionedEvent
+from a2a.server.cluster.task_store import (
+    ConcurrentTaskModificationError,
+    LegacyTaskStoreAdapter,
+    StoredTask,
+    VersionedTaskStore,
+)
+from a2a.server.cluster.version import TaskVersion
+
+
+logger = logging.getLogger(__name__)
+
+try:
+    from a2a.server.cluster.database_event_stream import DatabaseTaskEventStream
+    from a2a.server.cluster.database_task_store import (
+        VersionedDatabaseTaskStore,
+    )
+except ImportError as e:
+    _original_error = e
+    logger.debug(
+        'Database-backed cluster stores not loaded. This is expected if '
+        'database dependencies are not installed. Error: %s',
+        _original_error,
+    )
+
+    class VersionedDatabaseTaskStore:  # type: ignore[no-redef]
+        """Placeholder when database dependencies are not installed."""
+
+        def __init__(self, *args: object, **kwargs: object) -> None:
+            raise ImportError(
+                'To use VersionedDatabaseTaskStore, its dependencies must be '
+                "installed. Install with 'pip install a2a-sdk[sql]'."
+            ) from _original_error
+
+    class DatabaseTaskEventStream:  # type: ignore[no-redef]
+        """Placeholder when database dependencies are not installed."""
+
+        def __init__(self, *args: object, **kwargs: object) -> None:
+            raise ImportError(
+                'To use DatabaseTaskEventStream, its dependencies must be '
+                "installed. Install with 'pip install a2a-sdk[sql]'."
+            ) from _original_error
+
+
+__all__ = [
+    'ConcurrentTaskModificationError',
+    'DatabaseTaskEventStream',
+    'LegacyTaskStoreAdapter',
+    'StoredTask',
+    'TaskEventStream',
+    'TaskVersion',
+    'VersionedDatabaseTaskStore',
+    'VersionedEvent',
+    'VersionedTaskStore',
+]
diff --git a/src/a2a/server/cluster/database_event_stream.py b/src/a2a/server/cluster/database_event_stream.py
new file mode 100644
index 000000000..924a8e7e9
--- /dev/null
+++ b/src/a2a/server/cluster/database_event_stream.py
@@ -0,0 +1,212 @@
+import asyncio
+import logging
+
+from collections.abc import AsyncGenerator
+
+
+try:
+    from sqlalchemy import Table, and_, select
+    from sqlalchemy.exc import OperationalError
+    from sqlalchemy.ext.asyncio import (
+        AsyncEngine,
+        AsyncSession,
+        async_sessionmaker,
+    )
+    from sqlalchemy.orm import class_mapper
+except ImportError as e:
+    raise ImportError(
+        'DatabaseTaskEventStream requires SQLAlchemy and a database driver. '
+        'Install with one of: '
+        "'pip install a2a-sdk[postgresql]', "
+        "'pip install a2a-sdk[mysql]', "
+        "'pip install a2a-sdk[sqlite]', "
+        "or 'pip install a2a-sdk[sql]'"
+    ) from e
+
+from a2a.server.cluster.event_stream import TaskEventStream, VersionedEvent
+from a2a.server.cluster.version import TaskVersion
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue import Event
+from a2a.server.models import (
+    Base,
+    TaskEventModel,
+    create_task_event_model,
+)
+from a2a.server.owner_resolver import OwnerResolver
+from a2a.types.a2a_pb2 import StreamResponse
+
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_POLL_INTERVAL_S = 0.5
+
+
+def _as_int(version: TaskVersion) -> int:
+    """Extracts the integer value of a version, or raises if not an int."""
+    value = version._value  # noqa: SLF001
+    if not isinstance(value, int):
+        raise TypeError(
+            'DatabaseTaskEventStream requires integer versions, got '
+            f'{type(value).__name__}'
+        )
+    return value
+
+
+def stream_response_to_event(response: StreamResponse) -> Event:
+    """Converts a `StreamResponse` proto back to an internal `Event`."""
+    which = response.WhichOneof('payload')
+    if which == 'task':
+        return response.task
+    if which == 'message':
+        return response.message
+    if which == 'status_update':
+        return response.status_update
+    if which == 'artifact_update':
+        return response.artifact_update
+    raise ValueError(f'StreamResponse has no known payload set: {which!r}')
+
+
+class DatabaseTaskEventStream(TaskEventStream):
+    """`TaskEventStream` backed by polling the shared ``task_events`` table."""
+
+    _event_model: type[TaskEventModel]
+    owner_resolver: OwnerResolver | None
+
+    def __init__(
+        self,
+        engine: AsyncEngine,
+        create_table: bool = True,
+        table_name: str = 'task_events',
+        poll_interval_s: float = _DEFAULT_POLL_INTERVAL_S,
+        owner_resolver: OwnerResolver | None = None,
+    ) -> None:
+        """Initializes the stream over an existing SQLAlchemy AsyncEngine."""
+        self._engine = engine
+        self._session_maker = async_sessionmaker(engine, expire_on_commit=False)
+        self._create_table = create_table
+        self._poll_interval_s = poll_interval_s
+        self._initialized = False
+        self.owner_resolver = owner_resolver
+        self._event_model = (  # ty:ignore[invalid-assignment]
+            TaskEventModel
+            if table_name == 'task_events'
+            else create_task_event_model(table_name)
+        )
+
+    async def initialize(self) -> None:
+        """Creates the ``task_events`` table if requested."""
+        if self._initialized:
+            return
+        if self._create_table:
+            async with self._engine.begin() as conn:
+                mapper = class_mapper(self._event_model)
+                tables = [t for t in mapper.tables if isinstance(t, Table)]
+                await conn.run_sync(Base.metadata.create_all, tables=tables)
+        self._initialized = True
+
+    async def _ensure_initialized(self) -> None:
+        if not self._initialized:
+            await self.initialize()
+
+    async def publish(
+        self,
+        task_id: str,
+        event: VersionedEvent,
+        context: ServerCallContext | None = None,
+    ) -> None:
+        """No-op: events are persisted transactionally by the task store."""
+        del task_id, event, context
+
+    async def _seq_at_or_before_version(
+        self,
+        session: AsyncSession,
+        task_id: str,
+        after: TaskVersion,
+        owner: str | None,
+    ) -> int:
+        """Seq to start polling from so nothing after `after` is missed."""
+        if after.is_missing:
+            return 0
+        conditions = [
+            self._event_model.task_id == task_id,
+            self._event_model.task_version <= _as_int(after),
+        ]
+        if owner is not None:
+            conditions.append(self._event_model.owner == owner)
+        stmt = (
+            select(self._event_model.seq)
+            .where(and_(*conditions))
+            .order_by(self._event_model.seq.desc())
+            .limit(1)
+        )
+        result = (await session.execute(stmt)).scalar_one_or_none()
+        return result or 0
+
+    async def subscribe(  # type: ignore[override]
+        self,
+        task_id: str,
+        *,
+        after: TaskVersion,
+        context: ServerCallContext | None = None,
+    ) -> AsyncGenerator[VersionedEvent, None]:
+        """Polls the log for events of `task_id` newer than `after`."""
+        await self._ensure_initialized()
+        owner = (
+            self.owner_resolver(context or ServerCallContext())
+            if self.owner_resolver is not None
+            else None
+        )
+        async with self._session_maker() as session:
+            cursor = await self._seq_at_or_before_version(
+                session, task_id, after, owner
+            )
+
+        while True:
+            try:
+                async with self._session_maker() as session:
+                    conditions = [
+                        self._event_model.task_id == task_id,
+                        self._event_model.seq > cursor,
+                    ]
+                    if owner is not None:
+                        conditions.append(self._event_model.owner == owner)
+                    stmt = (
+                        select(
+                            self._event_model.seq,
+                            self._event_model.task_version,
+                            self._event_model.event_data,
+                        )
+                        .where(and_(*conditions))
+                        .order_by(self._event_model.seq.asc())
+                    )
+                    rows = (await session.execute(stmt)).all()
+            except OperationalError:
+                logger.debug(
+                    'Transient DB error polling events for %s; retrying',
+                    task_id,
+                    exc_info=True,
+                )
+                await asyncio.sleep(self._poll_interval_s)
+                continue
+
+            for row in rows:
+                seq, task_version, event_data = row[0], row[1], row[2]
+                cursor = seq
+                version = TaskVersion(task_version)
+                if not version.is_after(after):
+                    continue
+                response = StreamResponse()
+                response.ParseFromString(event_data)
+                yield VersionedEvent(
+                    event=stream_response_to_event(response),
+                    version=version,
+                )
+
+            if not rows:
+                await asyncio.sleep(self._poll_interval_s)
+
+    async def destroy(
+        self, task_id: str, context: ServerCallContext | None = None
+    ) -> None:
+        """No-op: the append-only log is retained; subscribers stop on their own."""
+        del task_id, context
diff --git a/src/a2a/server/cluster/database_task_store.py b/src/a2a/server/cluster/database_task_store.py
new file mode 100644
index 000000000..56e5f0884
--- /dev/null
+++ b/src/a2a/server/cluster/database_task_store.py
@@ -0,0 +1,377 @@
+import asyncio
+import logging
+
+from collections.abc import Callable
+
+
+try:
+    from sqlalchemy import Table, and_, delete, insert, select, update
+    from sqlalchemy.exc import DBAPIError, IntegrityError, OperationalError
+    from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+    from sqlalchemy.orm import class_mapper
+except ImportError as e:
+    raise ImportError(
+        'VersionedDatabaseTaskStore requires SQLAlchemy and a database driver. '
+        'Install with one of: '
+        "'pip install a2a-sdk[postgresql]', "
+        "'pip install a2a-sdk[mysql]', "
+        "'pip install a2a-sdk[sqlite]', "
+        "or 'pip install a2a-sdk[sql]'"
+    ) from e
+
+from a2a.server.cluster.task_store import (
+    ConcurrentTaskModificationError,
+    StoredTask,
+    VersionedTaskStore,
+)
+from a2a.server.cluster.version import TaskVersion
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue import Event
+from a2a.server.models import (
+    Base,
+    TaskEventModel,
+    TaskModel,
+    TaskVersionModel,
+    create_task_event_model,
+    create_task_version_model,
+)
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.tasks.database_task_store import DatabaseTaskStore
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types.a2a_pb2 import (
+    ListTasksRequest,
+    ListTasksResponse,
+    Task,
+    TaskState,
+)
+from a2a.utils.constants import TERMINAL_TASK_STATES
+from a2a.utils.proto_utils import to_stream_response
+
+
+logger = logging.getLogger(__name__)
+
+# DB contention retry
+_MAX_ATTEMPTS = 5
+_RETRY_DELAY_S = 0.02
+# Postgres deadlock and serialization failure. asyncpg reports these as a
+# generic DBAPIError rather than OperationalError.
+_TRANSIENT_ERROR_CODES = frozenset({'40P01', '40001'})
+
+
+def _is_transient(error: DBAPIError) -> bool:
+    """Whether `error` is DB contention that is safe to retry."""
+    return (
+        isinstance(error, OperationalError)
+        or getattr(error.orig, 'sqlstate', None) in _TRANSIENT_ERROR_CODES
+    )
+
+
+class VersionedDatabaseTaskStore(VersionedTaskStore):
+    """`VersionedTaskStore` backed by SQLAlchemy."""
+
+    _event_model: type[TaskEventModel]
+    _version_model: type[TaskVersionModel]
+
+    def __init__(  # noqa: PLR0913
+        self,
+        engine: AsyncEngine,
+        create_table: bool = True,
+        table_name: str = 'tasks',
+        owner_resolver: OwnerResolver = resolve_user_scope,
+        core_to_model_conversion: Callable[[Task, str], TaskModel]
+        | None = None,
+        model_to_core_conversion: Callable[[TaskModel], Task] | None = None,
+        event_table_name: str = 'task_events',
+        version_table_name: str = 'task_versions',
+        max_attempts: int = _MAX_ATTEMPTS,
+        retry_delay_s: float = _RETRY_DELAY_S,
+    ) -> None:
+        """Initializes the store, delegating schema to `DatabaseTaskStore`."""
+        self._db = DatabaseTaskStore(
+            engine=engine,
+            create_table=create_table,
+            table_name=table_name,
+            owner_resolver=owner_resolver,
+            core_to_model_conversion=core_to_model_conversion,
+            model_to_core_conversion=model_to_core_conversion,
+        )
+        self._create_table = create_table
+        self._max_attempts = max_attempts
+        self._retry_delay_s = retry_delay_s
+        self._event_model = (  # ty:ignore[invalid-assignment]
+            TaskEventModel
+            if event_table_name == 'task_events'
+            else create_task_event_model(event_table_name)
+        )
+        self._version_model = (  # ty:ignore[invalid-assignment]
+            TaskVersionModel
+            if version_table_name == 'task_versions'
+            else create_task_version_model(version_table_name)
+        )
+        self._cluster_tables_ready = False
+
+    @property
+    def as_task_store(self) -> TaskStore:
+        """The underlying non-versioned `TaskStore`."""
+        return self._db
+
+    async def initialize(self) -> None:
+        """Initializes the database schema (task, version and event tables)."""
+        await self._db.initialize()
+        await self._ensure_cluster_tables()
+
+    async def _ensure_cluster_tables(self) -> None:
+        if self._cluster_tables_ready:
+            return
+        if self._create_table:
+            async with self._db.engine.begin() as conn:
+                tables = [
+                    t
+                    for model in (self._version_model, self._event_model)
+                    for t in class_mapper(model).tables
+                    if isinstance(t, Table)
+                ]
+                await conn.run_sync(Base.metadata.create_all, tables=tables)
+        self._cluster_tables_ready = True
+
+    async def save(
+        self,
+        task: Task,
+        *,
+        event: Event | None = None,
+        prev: Task | None = None,
+        prev_version: TaskVersion,
+        context: ServerCallContext,
+    ) -> TaskVersion:
+        """Persists `task` with a compare-and-swap on the version side table.
+
+        The version lives in ``task_versions``, not on the tasks row, and
+        counts writes to the task: the first write sets 1 and every later
+        write adds 1. Updates CAS on it; cancel overwrites a non-terminal
+        task. When `event` is provided it is appended to ``task_events`` in the
+        same transaction for cross-replica replay.
+        """
+        del prev
+        await self._db._ensure_initialized()  # noqa: SLF001
+        await self._ensure_cluster_tables()
+        owner = self._db.owner_resolver(context)
+
+        # Retry only transient DB contention (e.g. lock/serialization errors).
+        # A ConcurrentTaskModificationError is the real signal and is never
+        # retried - it propagates so the caller can reload and decide.
+        attempts = 0
+        while True:
+            attempts += 1
+            try:
+                return await self._save_once(
+                    task, event=event, prev_version=prev_version, owner=owner
+                )
+            except DBAPIError as e:
+                if not _is_transient(e) or attempts >= self._max_attempts:
+                    raise
+                await asyncio.sleep(self._retry_delay_s * attempts)
+
+    async def _save_once(
+        self,
+        task: Task,
+        *,
+        event: Event | None,
+        prev_version: TaskVersion,
+        owner: str,
+    ) -> TaskVersion:
+        model = self._db._to_orm(task, owner)  # noqa: SLF001
+
+        # Every branch locks the task_versions row before the tasks row, so
+        # concurrent writers cannot deadlock.
+        async with self._db.async_session_maker.begin() as session:
+            if task.status.state == TaskState.TASK_STATE_CANCELED:
+                stored = await self._lock_version(session, task.id, owner)
+                current = await self._current_task(session, task.id, owner)
+                if (
+                    current is None
+                    or current.status.state in TERMINAL_TASK_STATES
+                ):
+                    raise ConcurrentTaskModificationError(task.id)
+                new_version = (stored or 0) + 1
+                if stored is None:
+                    await self._insert_version(
+                        session, task.id, owner, new_version
+                    )
+                else:
+                    await session.execute(
+                        update(self._version_model)
+                        .where(
+                            and_(
+                                self._version_model.task_id == task.id,
+                                self._version_model.owner == owner,
+                            )
+                        )
+                        .values(version=new_version)
+                    )
+            elif prev_version.is_missing:
+                new_version = 1
+                await self._insert_version(session, task.id, owner, new_version)
+            else:
+                new_version = _as_int(prev_version) + 1
+                result = await session.execute(
+                    update(self._version_model)
+                    .where(
+                        and_(
+                            self._version_model.task_id == task.id,
+                            self._version_model.owner == owner,
+                            self._version_model.version
+                            == _as_int(prev_version),
+                        )
+                    )
+                    .values(version=new_version)
+                )
+                if result.rowcount == 0:  # ty:ignore[unresolved-attribute]
+                    raise ConcurrentTaskModificationError(task.id)
+
+            await session.merge(model)
+
+            if event is not None:
+                await session.execute(
+                    insert(self._event_model).values(
+                        task_id=task.id,
+                        owner=owner,
+                        task_version=new_version,
+                        event_data=to_stream_response(
+                            event
+                        ).SerializeToString(),
+                    )
+                )
+
+        return TaskVersion(new_version)
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> StoredTask | None:
+        """Returns the task with its stored version, or None if absent.
+
+        Retries transient contention (e.g. a lock held while another writer
+        commits) rather than failing the read.
+        """
+        await self._db._ensure_initialized()  # noqa: SLF001
+        await self._ensure_cluster_tables()
+        owner = self._db.owner_resolver(context)
+        attempts = 0
+        while True:
+            attempts += 1
+            try:
+                return await self._get_once(task_id, owner)
+            except DBAPIError as e:
+                if not _is_transient(e) or attempts >= self._max_attempts:
+                    raise
+                await asyncio.sleep(self._retry_delay_s * attempts)
+
+    async def _get_once(self, task_id: str, owner: str) -> StoredTask | None:
+        task_model = self._db.task_model
+        version_model = self._version_model
+        async with self._db.async_session_maker() as session:
+            stmt = (
+                select(task_model, version_model.version)
+                .outerjoin(
+                    version_model,
+                    and_(
+                        version_model.task_id == task_model.id,
+                        version_model.owner == task_model.owner,
+                    ),
+                )
+                .where(
+                    and_(
+                        task_model.id == task_id,
+                        task_model.owner == owner,
+                    )
+                )
+            )
+            result = (await session.execute(stmt)).one_or_none()
+            if result is None:
+                return None
+            row, version_value = result
+            task = self._db._from_orm(row)  # noqa: SLF001
+            version = (
+                TaskVersion(version_value)
+                if version_value is not None
+                else TaskVersion.MISSING
+            )
+            return StoredTask(task, version)
+
+    async def _current_task(
+        self, session: AsyncSession, task_id: str, owner: str
+    ) -> Task | None:
+        task_model = self._db.task_model
+        row = (
+            await session.execute(
+                select(task_model)
+                .where(
+                    and_(task_model.id == task_id, task_model.owner == owner)
+                )
+                .with_for_update()
+            )
+        ).scalar_one_or_none()
+        return self._db._from_orm(row) if row is not None else None  # noqa: SLF001
+
+    async def _lock_version(
+        self, session: AsyncSession, task_id: str, owner: str
+    ) -> int | None:
+        return (
+            await session.execute(
+                select(self._version_model.version)
+                .where(
+                    and_(
+                        self._version_model.task_id == task_id,
+                        self._version_model.owner == owner,
+                    )
+                )
+                .with_for_update()
+            )
+        ).scalar_one_or_none()
+
+    async def _insert_version(
+        self, session: AsyncSession, task_id: str, owner: str, version: int
+    ) -> None:
+        # The insert is what makes one of two concurrent first writers lose.
+        try:
+            await session.execute(
+                insert(self._version_model).values(
+                    task_id=task_id, owner=owner, version=version
+                )
+            )
+        except IntegrityError as e:
+            raise ConcurrentTaskModificationError(task_id) from e
+
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Lists tasks via the underlying store."""
+        return await self._db.list(params, context)
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task and its version row via the underlying store."""
+        await self._db._ensure_initialized()  # noqa: SLF001
+        await self._ensure_cluster_tables()
+        owner = self._db.owner_resolver(context)
+        await self._db.delete(task_id, context)
+        async with self._db.async_session_maker.begin() as session:
+            await session.execute(
+                delete(self._version_model).where(
+                    and_(
+                        self._version_model.task_id == task_id,
+                        self._version_model.owner == owner,
+                    )
+                )
+            )
+
+
+def _as_int(version: TaskVersion) -> int:
+    """Extracts the integer value of a version, or raises if not an int."""
+    value = version._value  # noqa: SLF001
+    if not isinstance(value, int):
+        raise TypeError(
+            'VersionedDatabaseTaskStore requires integer versions, got '
+            f'{type(value).__name__}'
+        )
+    return value
diff --git a/src/a2a/server/cluster/event_stream.py b/src/a2a/server/cluster/event_stream.py
new file mode 100644
index 000000000..924e047e2
--- /dev/null
+++ b/src/a2a/server/cluster/event_stream.py
@@ -0,0 +1,74 @@
+import inspect
+import logging
+import warnings
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+
+from a2a.server.cluster.version import TaskVersion
+from a2a.server.events.event_queue import Event
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class VersionedEvent:
+    """An event together with the task version produced by applying it."""
+
+    event: Event
+    version: TaskVersion
+
+
+class TaskEventStream(ABC):
+    """Delivers task events across replicas."""
+
+    @abstractmethod
+    async def publish(self, task_id: str, event: VersionedEvent) -> None:
+        """Publishes one event for `task_id` to all replicas."""
+
+    @abstractmethod
+    def subscribe(
+        self, task_id: str, *, after: TaskVersion
+    ) -> AsyncGenerator[VersionedEvent, None]:
+        """Yields events for `task_id` newer than `after`."""
+
+    @abstractmethod
+    async def destroy(self, task_id: str) -> None:
+        """Releases resources for a task that has reached a terminal state."""
+
+
+_context_support_cache: dict[tuple[type, str], bool] = {}
+
+
+def _stream_accepts_context(stream: TaskEventStream, method_name: str) -> bool:
+    """Temporary solution to support ServerCallContext being passed to TaskEventStream.
+
+    Checks if given method of TaskEventStream accepts context parameter.
+    If not, it logs a warning and returns False.
+
+    TODO(ISSUE #1374): remove this function once ServerCallContext is a required parameter on TaskEventStream.
+    """
+    key = (type(stream), method_name)
+    cached = _context_support_cache.get(key)
+    if cached is not None:
+        return cached
+
+    params = inspect.signature(getattr(stream, method_name)).parameters
+    accepts = 'context' in params or any(
+        p.kind is p.VAR_KEYWORD for p in params.values()
+    )
+    _context_support_cache[key] = accepts
+
+    if not accepts:
+        message = (
+            f'{type(stream).__name__}.{method_name} does not accept a '
+            "'context' parameter; ownership checks are skipped for this "
+            'TaskEventStream implementation. This will become a required '
+            'parameter in a future major version.'
+        )
+        warnings.warn(message, DeprecationWarning, stacklevel=3)
+        logger.warning(message)
+
+    return accepts
diff --git a/src/a2a/server/cluster/task_store.py b/src/a2a/server/cluster/task_store.py
new file mode 100644
index 000000000..aed8777fe
--- /dev/null
+++ b/src/a2a/server/cluster/task_store.py
@@ -0,0 +1,128 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from a2a.server.cluster.version import TaskVersion
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue import Event
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types.a2a_pb2 import ListTasksRequest, ListTasksResponse, Task
+
+
+@dataclass(frozen=True)
+class StoredTask:
+    """A task together with the version it was read at."""
+
+    task: Task
+    version: TaskVersion
+
+
+class ConcurrentTaskModificationError(Exception):
+    """Raised by `VersionedTaskStore.save` when `prev_version` is stale."""
+
+    def __init__(self, task_id: str) -> None:
+        super().__init__(
+            f'Task {task_id} was modified concurrently by another writer'
+        )
+        self.task_id = task_id
+
+
+class VersionedTaskStore(ABC):
+    """A `TaskStore` variant with snapshot versioning to prevent concurrent re-writes."""
+
+    @abstractmethod
+    async def save(
+        self,
+        task: Task,
+        *,
+        event: Event | None,
+        prev: Task | None,
+        prev_version: TaskVersion,
+        context: ServerCallContext,
+    ) -> TaskVersion:
+        """Persists `task` and returns its new version.
+
+        Args:
+            task: The task state to persist.
+            event: The event that produced this state, or `None` for a direct
+                write.
+            prev: The task as previously read, for implementations that diff.
+            prev_version: The version `task` was derived from. Implementations
+                MUST raise `ConcurrentTaskModificationError` if the currently
+                stored version differs. `TaskVersion.MISSING` marks a first
+                write. A write moving `task` to CANCELED overwrites a
+                non-terminal stored task without a version check, and raises
+                `ConcurrentTaskModificationError` if the stored task is already
+                terminal or absent.
+            context: The server call context (used to resolve the owner).
+
+        Returns:
+            The new `TaskVersion` for the persisted task.
+
+        Raises:
+            ConcurrentTaskModificationError: If `prev_version` is stale.
+        """
+
+    @abstractmethod
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> StoredTask | None:
+        """Retrieves a task with its version, or `None` if it does not exist."""
+
+    @abstractmethod
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Retrieves a list of tasks from the store."""
+
+    @abstractmethod
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the store by ID."""
+
+
+class LegacyTaskStoreAdapter(VersionedTaskStore):
+    """Runs an unversioned `TaskStore` under the `VersionedTaskStore` interface."""
+
+    def __init__(self, store: TaskStore) -> None:
+        self._store = store
+
+    @property
+    def store(self) -> TaskStore:
+        """The wrapped task store."""
+        return self._store
+
+    async def save(
+        self,
+        task: Task,
+        *,
+        event: Event | None,
+        prev: Task | None,
+        prev_version: TaskVersion,
+        context: ServerCallContext,
+    ) -> TaskVersion:
+        """Saves via the wrapped store; ignores version args, returns MISSING."""
+        del event, prev, prev_version  # unversioned store ignores these
+        await self._store.save(task, context)
+        return TaskVersion.MISSING
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> StoredTask | None:
+        """Gets from the wrapped store, pairing the result with MISSING."""
+        task = await self._store.get(task_id, context)
+        if task is None:
+            return None
+        return StoredTask(task, TaskVersion.MISSING)
+
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Lists tasks via the wrapped store."""
+        return await self._store.list(params, context)
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task via the wrapped store."""
+        await self._store.delete(task_id, context)
diff --git a/src/a2a/server/cluster/version.py b/src/a2a/server/cluster/version.py
new file mode 100644
index 000000000..5a2f05062
--- /dev/null
+++ b/src/a2a/server/cluster/version.py
@@ -0,0 +1,54 @@
+from typing import ClassVar
+
+
+class TaskVersion:
+    """A version marker a `VersionedTaskStore` assigns to a stored `Task`.
+
+    Prevents concurrent state re-writes. The wrapped value is the store's
+    choice - a counter, a commit timestamp, etc. Callers do not read it or do
+    arithmetic on it; they only pass it back to `save` and order two versions
+    with `is_after`.
+    """
+
+    __slots__ = ('_value',)
+
+    MISSING: 'ClassVar[TaskVersion]'
+
+    def __init__(self, value: int | str) -> None:
+        self._value = value
+
+    def __eq__(self, other: object) -> bool:
+        """Two versions are equal when they wrap equal values."""
+        return isinstance(other, TaskVersion) and self._value == other._value
+
+    def __hash__(self) -> int:
+        """Hash by the wrapped value so versions are usable as keys."""
+        return hash(self._value)
+
+    def __repr__(self) -> str:
+        """Render `MISSING` specially, otherwise show the wrapped value."""
+        if self.is_missing:
+            return 'TaskVersion.MISSING'
+        return f'TaskVersion({self._value!r})'
+
+    @property
+    def is_missing(self) -> bool:
+        """Whether this token means "versioning is not tracked"."""
+        return self._value == 0
+
+    def is_after(self, other: 'TaskVersion') -> bool:
+        """Whether `self` is a strictly later version than `other`."""
+        if other.is_missing:
+            return True
+        if self.is_missing:
+            return False
+        if type(self._value) is not type(other._value):  # noqa: SLF001
+            raise TypeError(
+                'Cannot compare TaskVersions with different value types: '
+                f'{type(other._value).__name__} and '  # noqa: SLF001
+                f'{type(self._value).__name__}'
+            )
+        return other._value < self._value  # ty:ignore[unsupported-operator]  # noqa: SLF001
+
+
+TaskVersion.MISSING = TaskVersion(0)
diff --git a/src/a2a/server/context.py b/src/a2a/server/context.py
new file mode 100644
index 000000000..833ca44c4
--- /dev/null
+++ b/src/a2a/server/context.py
@@ -0,0 +1,25 @@
+"""Defines the ServerCallContext class."""
+
+import collections.abc
+import typing
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from a2a.auth.user import UnauthenticatedUser, User
+
+
+State = collections.abc.MutableMapping[str, typing.Any]
+
+
+class ServerCallContext(BaseModel):
+    """A context passed when calling a server method.
+
+    This class allows storing arbitrary user data in the state attribute.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    state: State = Field(default_factory=dict)
+    user: User = Field(default_factory=UnauthenticatedUser)
+    tenant: str = Field(default='')
+    requested_extensions: set[str] = Field(default_factory=set)
diff --git a/src/a2a/server/events/__init__.py b/src/a2a/server/events/__init__.py
index d9662d040..8af917ef7 100644
--- a/src/a2a/server/events/__init__.py
+++ b/src/a2a/server/events/__init__.py
@@ -1,5 +1,7 @@
+"""Event handling components for the A2A server."""
+
 from a2a.server.events.event_consumer import EventConsumer
-from a2a.server.events.event_queue import Event, EventQueue
+from a2a.server.events.event_queue import Event, EventQueue, EventQueueLegacy
 from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
 from a2a.server.events.queue_manager import (
     NoTaskQueue,
@@ -12,6 +14,7 @@
     'Event',
     'EventConsumer',
     'EventQueue',
+    'EventQueueLegacy',
     'InMemoryQueueManager',
     'NoTaskQueue',
     'QueueManager',
diff --git a/src/a2a/server/events/event_consumer.py b/src/a2a/server/events/event_consumer.py
index dcfa9d983..8414e2d17 100644
--- a/src/a2a/server/events/event_consumer.py
+++ b/src/a2a/server/events/event_consumer.py
@@ -3,76 +3,121 @@
 
 from collections.abc import AsyncGenerator
 
-from a2a.server.events.event_queue import Event, EventQueue
-from a2a.types import (
-    InternalError,
+from pydantic import ValidationError
+
+from a2a.server.events.event_queue import Event, EventQueueLegacy, QueueShutDown
+from a2a.types.a2a_pb2 import (
     Message,
     Task,
     TaskState,
     TaskStatusUpdateEvent,
 )
-from a2a.utils.errors import ServerError
+from a2a.utils.telemetry import SpanKind, trace_class
 
 
 logger = logging.getLogger(__name__)
 
 
+@trace_class(kind=SpanKind.SERVER)
 class EventConsumer:
     """Consumer to read events from the agent event queue."""
 
-    def __init__(self, queue: EventQueue):
+    def __init__(self, queue: EventQueueLegacy):
+        """Initializes the EventConsumer.
+
+        Args:
+            queue: The `EventQueue` instance to consume events from.
+        """
         self.queue = queue
+        self._timeout = 0.5
+        self._exception: BaseException | None = None
         logger.debug('EventConsumer initialized')
 
-    async def consume_one(self) -> Event:
-        """Consume one event from the agent event queue."""
-        logger.debug('Attempting to consume one event.')
-        try:
-            event = await self.queue.dequeue_event(no_wait=True)
-        except asyncio.QueueEmpty as e:
-            logger.warning('Event queue was empty in consume_one.')
-            raise ServerError(
-                InternalError(message='Agent did not return any response')
-            ) from e
-
-        logger.debug(f'Dequeued event of type: {type(event)} in consume_one.')
+    async def consume_all(self) -> AsyncGenerator[Event]:
+        """Consume all the generated streaming events from the agent.
 
-        self.queue.task_done()
+        This method yields events as they become available from the queue
+        until a final event is received or the queue is closed. It also
+        monitors for exceptions set by the `agent_task_callback`.
 
-        return event
+        Yields:
+            Events dequeued from the queue.
 
-    async def consume_all(self) -> AsyncGenerator[Event]:
-        """Consume all the generated streaming events from the agent."""
+        Raises:
+            BaseException: If an exception was set by the `agent_task_callback`.
+        """
         logger.debug('Starting to consume all events from the queue.')
         while True:
+            if self._exception:
+                raise self._exception
             try:
-                event = await self.queue.dequeue_event()
+                # We use a timeout when waiting for an event from the queue.
+                # This is required because it allows the loop to check if
+                # `self._exception` has been set by the `agent_task_callback`.
+                # Without the timeout, loop might hang indefinitely if no events are
+                # enqueued by the agent and the agent simply threw an exception
+                event = await asyncio.wait_for(
+                    self.queue.dequeue_event(), timeout=self._timeout
+                )
                 logger.debug(
-                    f'Dequeued event of type: {type(event)} in consume_all.'
+                    'Dequeued event of type: %s in consume_all.', type(event)
                 )
-                yield event
                 self.queue.task_done()
                 logger.debug(
                     'Marked task as done in event queue in consume_all'
                 )
 
-                is_final_event = (
-                    (isinstance(event, TaskStatusUpdateEvent) and event.final)
-                    or isinstance(event, Message)
-                    or (
-                        isinstance(event, Task)
-                        and event.status.state
-                        in (
-                            TaskState.completed,
-                            TaskState.canceled,
-                            TaskState.failed,
-                        )
+                is_final_event = isinstance(event, Message) or (
+                    isinstance(event, Task | TaskStatusUpdateEvent)
+                    and event.status.state
+                    in (
+                        TaskState.TASK_STATE_COMPLETED,
+                        TaskState.TASK_STATE_CANCELED,
+                        TaskState.TASK_STATE_FAILED,
+                        TaskState.TASK_STATE_REJECTED,
+                        TaskState.TASK_STATE_UNSPECIFIED,
+                        TaskState.TASK_STATE_INPUT_REQUIRED,
                     )
                 )
 
+                # Make sure the yield is after the close events, otherwise
+                # the caller may end up in a blocked state where this
+                # generator isn't called again to close things out and the
+                # other part is waiting for an event or a closed queue.
                 if is_final_event:
                     logger.debug('Stopping event consumption in consume_all.')
-                    self.queue.close()
+                    await self.queue.close(True)
+                    yield event
+                    break
+                yield event
+            except TimeoutError:
+                # continue polling until there is a final event
+                continue
+            except asyncio.TimeoutError:  # pyright: ignore [reportUnusedExcept]
+                # This class was made an alias of built-in TimeoutError after 3.11
+                continue
+            except (QueueShutDown, asyncio.QueueEmpty):
+                # Confirm that the queue is closed, e.g. we aren't on
+                # python 3.12 and get a queue empty error on an open queue
+                if self.queue.is_closed():
                     break
-            except asyncio.QueueShutDown:
-                break
+            except ValidationError:
+                logger.exception('Invalid event format received')
+                continue
+            except Exception as e:
+                logger.exception('Stopping event consumption due to exception')
+                self._exception = e
+                continue
+
+    def agent_task_callback(self, agent_task: asyncio.Task[None]) -> None:
+        """Callback to handle exceptions from the agent's execution task.
+
+        If the agent's asyncio task raises an exception, this callback is
+        invoked, and the exception is stored to be re-raised by the consumer loop.
+
+        Args:
+            agent_task: The asyncio.Task that completed.
+        """
+        logger.debug('Agent task callback triggered.')
+        if not agent_task.cancelled() and agent_task.done():
+            self._exception = agent_task.exception()
diff --git a/src/a2a/server/events/event_queue.py b/src/a2a/server/events/event_queue.py
index ec651761f..ecab0ea3a 100644
--- a/src/a2a/server/events/event_queue.py
+++ b/src/a2a/server/events/event_queue.py
@@ -1,71 +1,214 @@
 import asyncio
 import logging
+import warnings
 
-from typing import Any
+from abc import ABC, abstractmethod
+from types import TracebackType
+from typing import Any, cast
 
-from a2a.types import (
-    A2AError,
-    JSONRPCError,
+from typing_extensions import Self
+
+from a2a.types.a2a_pb2 import (
     Message,
     Task,
     TaskArtifactUpdateEvent,
     TaskStatusUpdateEvent,
 )
+from a2a.utils._async_queue_compat import (
+    AsyncQueue,
+    QueueShutDown,
+    create_async_queue,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
 
 
 logger = logging.getLogger(__name__)
 
 
-Event = (
-    Message
-    | Task
-    | TaskStatusUpdateEvent
-    | TaskArtifactUpdateEvent
-    | A2AError
-    | JSONRPCError
-)
+Event = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+"""Type alias for events that can be enqueued."""
+
+DEFAULT_MAX_QUEUE_SIZE = 1024
+
 
+class EventQueue(ABC):
+    """Producer-side interface passed to `AgentExecutor.execute`/`cancel`.
+
+    Exposes only `enqueue_event`. The consumer is framework-managed
+    and not part of the public surface.
+
+    Default request handlers construct the queue and pass it in; executors
+    should accept it and not construct one. To run an executor outside the
+    framework, write a custom subclass or use `EventQueueLegacy` (deprecated,
+    will be removed in a future release).
+    """
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
+        """Deprecated: redirects bare `EventQueue(...)` to `EventQueueLegacy(...)`."""
+        if cls is EventQueue:
+            warnings.warn(
+                'EventQueue is an abstract interface; instantiating it '
+                'directly is deprecated. The redirect to EventQueueLegacy '
+                '(and EventQueueLegacy itself) will be removed in a future '
+                'release.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            instance = EventQueueLegacy.__new__(EventQueueLegacy)
+            EventQueueLegacy.__init__(instance, *args, **kwargs)
+            return cast('Self', instance)
+        return super().__new__(cls)
 
-class EventQueue:
-    """Event queue for A2A responses from agent."""
+    @abstractmethod
+    async def enqueue_event(self, event: Event) -> None:
+        """Pushes an event into the queue.
 
-    def __init__(self) -> None:
-        self.queue: asyncio.Queue[Event] = asyncio.Queue()
-        self._children: list[EventQueue] = []
+        Only main queue can enqueue events. Child queues can only dequeue events.
+        """
+
+
+@trace_class(kind=SpanKind.SERVER)
+class EventQueueLegacy(EventQueue):
+    """Event queue for A2A responses from agent.
+
+    Acts as a buffer between the agent's asynchronous execution and the
+    server's response handling (e.g., streaming via SSE). Supports tapping
+    to create child queues that receive the same events.
+    """
+
+    def __init__(self, max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE) -> None:
+        """Initializes the EventQueue."""
+        # Make sure the `asyncio.Queue` is bounded.
+        # If it's unbounded (maxsize=0), then `queue.put()` never needs to wait,
+        # and so the streaming won't work correctly.
+        if max_queue_size <= 0:
+            raise ValueError('max_queue_size must be greater than 0')
+
+        self._queue: AsyncQueue[Event] = create_async_queue(
+            maxsize=max_queue_size
+        )
+        self._children: list[EventQueueLegacy] = []
+        self._is_closed = False
+        self._lock = asyncio.Lock()
         logger.debug('EventQueue initialized.')
 
-    def enqueue_event(self, event: Event):
-        logger.debug(f'Enqueuing event of type: {type(event)}')
-        self.queue.put_nowait(event)
+    @property
+    def queue(self) -> AsyncQueue[Event]:
+        """[DEPRECATED] Returns the underlying asyncio.Queue."""
+        return self._queue
+
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager, returning the queue itself."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager, ensuring close() is called."""
+        await self.close()
+
+    async def enqueue_event(self, event: Event) -> None:
+        """Enqueues an event to this queue and all its children.
+
+        Args:
+            event: The event object to enqueue.
+        """
+        async with self._lock:
+            if self._is_closed:
+                logger.warning('Queue is closed. Event will not be enqueued.')
+                return
+
+        logger.debug('Enqueuing event of type: %s', type(event))
+
+        try:
+            await self.queue.put(event)
+        except QueueShutDown:
+            logger.warning('Queue was closed during enqueuing. Event dropped.')
+            return
+
         for child in self._children:
-            child.enqueue_event(event)
-
-    async def dequeue_event(self, no_wait: bool = False) -> Event:
-        if no_wait:
-            logger.debug('Attempting to dequeue event (no_wait=True).')
-            event = self.queue.get_nowait()
-            logger.debug(
-                f'Dequeued event (no_wait=True) of type: {type(event)}'
-            )
-            return event
+            await child.enqueue_event(event)
+
+    async def dequeue_event(self) -> Event:
+        """Dequeues an event from the queue.
+
+        This implementation expects that dequeue to raise an exception when
+        the queue has been closed. In python 3.13+ this is naturally provided
+        by the QueueShutDown exception generated when the queue has closed and
+        the user is awaiting the queue.get method. Python<=3.12 this needs to
+        manage this lifecycle itself. The current implementation can lead to
+        blocking if the dequeue_event is called before the EventQueue has been
+        closed but when there are no events on the queue. One way to avoid this
+        is to use an async Task management solution to cancel the get task if the queue
+        has closed or some other condition is met. The implementation of the
+        EventConsumer uses an async.wait with a timeout to abort the
+        dequeue_event call and retry, when it will return with a closed error.
+
+        Returns:
+            The next event from the queue.
+
+        Raises:
+            asyncio.QueueShutDown: If the queue has been closed and is empty.
+        """
+        async with self._lock:
+            if self._is_closed and self.queue.empty():
+                logger.warning('Queue is closed. Event will not be dequeued.')
+                raise QueueShutDown('Queue is closed.')
 
         logger.debug('Attempting to dequeue event (waiting).')
         event = await self.queue.get()
-        logger.debug(f'Dequeued event (waited) of type: {type(event)}')
+        logger.debug('Dequeued event (waited) of type: %s', type(event))
         return event
 
     def task_done(self) -> None:
+        """Signals that a formerly enqueued task is complete.
+
+        Used in conjunction with `dequeue_event` to track processed items.
+        """
         logger.debug('Marking task as done in EventQueue.')
         self.queue.task_done()
 
-    def tap(self) -> Any:
-        """Taps the event queue to branch the future events."""
-        queue = EventQueue()
+    async def tap(
+        self, max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE
+    ) -> 'EventQueueLegacy':
+        """Taps the event queue to create a new child queue that receives future events.
+
+        Returns:
+            A new `EventQueue` instance that will receive all events enqueued
+            to this parent queue from this point forward.
+        """
+        logger.debug('Tapping EventQueue to create a child queue.')
+        queue = EventQueueLegacy(max_queue_size=max_queue_size)
         self._children.append(queue)
         return queue
 
-    def close(self):
-        """Closes the queue for future push events."""
-        self.queue.shutdown()
-        for child in self._children:
-            child.close()
+    async def close(self, immediate: bool = False) -> None:
+        """Closes the queue for future push events and also closes all child queues.
+
+        Args:
+            immediate: If True, immediately flushes the queue, discarding all pending
+                events, and causes any currently blocked `dequeue_event` calls to raise
+                `QueueShutDown`. If False (default), the queue is marked as closed to new
+                events, but existing events can still be dequeued and processed until the
+                queue is fully drained.
+        """
+        logger.debug('Closing EventQueue.')
+        async with self._lock:
+            if self._is_closed and not immediate:
+                return
+            self._is_closed = True
+
+        self.queue.shutdown(immediate)
+
+        await asyncio.gather(
+            *(child.close(immediate) for child in self._children)
+        )
+        if not immediate:
+            await self.queue.join()
+
+    def is_closed(self) -> bool:
+        """Checks if the queue is closed."""
+        return self._is_closed
diff --git a/src/a2a/server/events/event_queue_v2.py b/src/a2a/server/events/event_queue_v2.py
new file mode 100644
index 000000000..307c8c9e9
--- /dev/null
+++ b/src/a2a/server/events/event_queue_v2.py
@@ -0,0 +1,477 @@
+import asyncio
+import contextlib
+import logging
+
+from types import TracebackType
+
+from typing_extensions import Self
+
+from a2a.server.events.event_queue import (
+    DEFAULT_MAX_QUEUE_SIZE,
+    AsyncQueue,
+    Event,
+    EventQueue,
+    QueueShutDown,
+    create_async_queue,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+logger = logging.getLogger(__name__)
+
+
+@trace_class(kind=SpanKind.SERVER)
+class EventQueueSource(EventQueue):
+    """The Parent EventQueue.
+
+    Acts as the single entry point for producers. Events pushed here are buffered
+    in `_incoming_queue` and distributed to all child Sinks by a background dispatcher task.
+    """
+
+    def __init__(
+        self,
+        max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE,
+        create_default_sink: bool = True,
+    ) -> None:
+        """Initializes the EventQueueSource."""
+        if max_queue_size <= 0:
+            raise ValueError('max_queue_size must be greater than 0')
+
+        self._incoming_queue: AsyncQueue[Event] = create_async_queue(
+            maxsize=max_queue_size
+        )
+        self._lock = asyncio.Lock()
+        self._sinks: set[EventQueueSink] = set()
+        self._is_closed = False
+
+        # Internal sink for backward compatibility
+        self._default_sink: EventQueueSink | None
+        if create_default_sink:
+            self._default_sink = EventQueueSink(
+                parent=self, max_queue_size=max_queue_size
+            )
+            self._sinks.add(self._default_sink)
+        else:
+            self._default_sink = None
+
+        self._dispatcher_task = asyncio.create_task(self._dispatch_loop())
+
+        self._dispatcher_task_expected_to_cancel = False
+
+        logger.debug('EventQueueSource initialized.')
+
+    @property
+    def queue(self) -> AsyncQueue[Event]:
+        """Returns the underlying asyncio.Queue of the default sink."""
+        if self._default_sink is None:
+            raise ValueError('No default sink available.')
+        return self._default_sink.queue
+
+    async def _deliver_to_sink(
+        self, sink: 'EventQueueSink', event: Event
+    ) -> None:
+        """Puts one event into one sink, evicting an evict-on-full sink if full.
+
+        A sink whose queue has filled up would, with a blocking put, stall
+        this dispatcher's ``gather`` until the sink drains: if it never does,
+        the incoming queue then fills, producers wedge in ``enqueue_event``,
+        and the task's event flow never recovers. Sinks tapped with
+        ``evict_on_full=True`` are therefore treated as broadcast observers:
+        when full, the sink is force-closed and detached so dispatch to the
+        remaining sinks continues and blocked producers recover. Sinks with
+        ``evict_on_full=False`` (including the default sink) keep the blocking
+        put, which is the documented flow-control contract.
+
+        The eviction condition is queue fullness at delivery time, which says
+        nothing about why the consumer is behind. A departed consumer and a
+        slow one are evicted alike.
+
+        The ``full()`` pre-check is race-free: this dispatcher is the only
+        writer to a sink queue and consumers only read, so the queue cannot
+        grow between the check and the put.
+
+        A sink that closed after the dispatch snapshot was taken (e.g. a
+        graceful ``close(immediate=False)`` whose consumer is still
+        draining) is skipped: treating its full queue as an eviction
+        candidate would upgrade the close to immediate and discard the
+        events the consumer is draining. The check is best-effort — a
+        close landing after it is harmless, because the put below
+        tolerates a shut-down queue.
+        """
+        if sink.is_closed():
+            return
+        if sink._evict_on_full and sink.queue.full():  # noqa: SLF001
+            logger.warning(
+                'Evicting event queue sink %r: queue full at delivery time '
+                '(>= max_queue_size events behind); closing it so dispatch '
+                'continues.',
+                sink,
+            )
+            await sink.close(immediate=True)
+            return
+        await sink._put_internal(event)  # noqa: SLF001
+
+    async def _dispatch_loop(self) -> None:
+        try:
+            while True:
+                event = await self._incoming_queue.get()
+
+                async with self._lock:
+                    active_sinks = list(self._sinks)
+
+                if active_sinks:
+                    results = await asyncio.gather(
+                        *(
+                            self._deliver_to_sink(sink, event)
+                            for sink in active_sinks
+                        ),
+                        return_exceptions=True,
+                    )
+                    for result in results:
+                        if isinstance(result, Exception):
+                            logger.error(
+                                'Error dispatching event to sink',
+                                exc_info=result,
+                            )
+
+                self._incoming_queue.task_done()
+        except asyncio.CancelledError:
+            logger.debug(
+                'EventQueueSource._dispatch_loop() for %s was cancelled',
+                self,
+            )
+            if not self._dispatcher_task_expected_to_cancel:
+                # This should only happen on forced shutdown (e.g. tests, server forced stop, etc).
+                logger.info(
+                    'EventQueueSource._dispatch_loop() for %s was cancelled without '
+                    'calling EventQueue.close() first.',
+                    self,
+                )
+                async with self._lock:
+                    self._is_closed = True
+                    sinks_to_close = list(self._sinks)
+
+                self._incoming_queue.shutdown(immediate=True)
+                await asyncio.gather(
+                    *(sink.close(immediate=True) for sink in sinks_to_close)
+                )
+            raise
+        except QueueShutDown:
+            logger.debug('EventQueueSource._dispatch_loop() shutdown %s', self)
+        except Exception:
+            logger.exception(
+                'EventQueueSource._dispatch_loop() failed %s', self
+            )
+            raise
+        finally:
+            logger.debug('EventQueueSource._dispatch_loop() Completed %s', self)
+
+    async def _join_incoming_queue(self) -> None:
+        """Helper to wait for join() while monitoring the dispatcher task."""
+        if self._dispatcher_task.done():
+            logger.warning(
+                'Dispatcher task is not running. Cannot wait for event dispatch.'
+            )
+            return
+
+        join_task = asyncio.create_task(self._incoming_queue.join())
+        try:
+            done, _pending = await asyncio.wait(
+                [join_task, self._dispatcher_task],
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+        except asyncio.CancelledError:
+            join_task.cancel()
+            raise
+
+        if join_task in done:
+            return
+
+        # Dispatcher task finished before join()
+        join_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await join_task
+
+        try:
+            if self._dispatcher_task.exception():
+                logger.error(
+                    'Dispatcher task failed. Events may be lost.',
+                    exc_info=self._dispatcher_task.exception(),
+                )
+            else:
+                logger.warning(
+                    'Dispatcher task finished unexpectedly. Events may be lost.'
+                )
+        except (asyncio.CancelledError, asyncio.InvalidStateError):
+            logger.warning(
+                'Dispatcher task was cancelled or finished. Events may be lost.'
+            )
+
+    async def tap(
+        self,
+        max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE,
+        evict_on_full: bool = False,
+    ) -> 'EventQueueSink':
+        """Taps the event queue to create a new child queue that receives future events.
+
+        Note: The tapped queue may receive some old events if the incoming event
+        queue is lagging behind and hasn't dispatched them yet.
+
+        Args:
+            max_queue_size: Bound for the new sink's queue.
+            evict_on_full: When True, the dispatcher treats this sink as a
+                broadcast observer: if its queue is full at delivery time, the
+                sink is force-closed and detached instead of blocking dispatch
+                (and, transitively, every producer) behind it. When False (the
+                default), a full sink back-pressures dispatch, preserving the
+                documented flow-control behavior. Use True for sinks that may
+                fall more than ``max_queue_size`` events behind the dispatcher,
+                such as remote subscribers, whether because their consumer went
+                away or because it is merely slow.
+        """
+        async with self._lock:
+            if self._is_closed:
+                raise QueueShutDown('Cannot tap a closed EventQueueSource.')
+            sink = EventQueueSink(
+                parent=self,
+                max_queue_size=max_queue_size,
+                evict_on_full=evict_on_full,
+            )
+            self._sinks.add(sink)
+            return sink
+
+    async def remove_sink(self, sink: 'EventQueueSink') -> None:
+        """Removes a sink from the source's internal list if present."""
+        async with self._lock:
+            self._sinks.discard(sink)
+
+    async def enqueue_event(self, event: Event) -> None:
+        """Enqueues an event to this queue and all its children."""
+        logger.debug('Enqueuing event of type: %s', type(event))
+        try:
+            await self._incoming_queue.put(event)
+        except QueueShutDown:
+            logger.warning('Queue was closed during enqueuing. Event dropped.')
+            return
+
+    async def dequeue_event(self) -> Event:
+        """Pulls an event from the default internal sink queue."""
+        if self._default_sink is None:
+            raise ValueError('No default sink available.')
+        return await self._default_sink.dequeue_event()
+
+    def task_done(self) -> None:
+        """Signals that a work on dequeued event is complete via the default internal sink queue."""
+        if self._default_sink is None:
+            raise ValueError('No default sink available.')
+        self._default_sink.task_done()
+
+    async def close(self, immediate: bool = False) -> None:
+        """Closes the queue and all its child sinks.
+
+        It is safe to call it multiple times.
+        If immediate is True, the queue will be closed without waiting for all events to be processed.
+        If immediate is False, the queue will be closed after all events are processed (and confirmed with task_done() calls).
+
+        WARNING: Closing the parent queue with immediate=False is a deadlock risk if there are unconsumed events
+        in any of the child sinks and the consumer has crashed without draining its queue.
+        It is highly recommended to wrap graceful shutdowns with a timeout, e.g.,
+        `asyncio.wait_for(queue.close(immediate=False), timeout=...)`.
+        """
+        logger.debug('Closing EventQueueSource: immediate=%s', immediate)
+        async with self._lock:
+            # No more tap() allowed.
+            self._is_closed = True
+            # No more new events can be enqueued.
+            self._incoming_queue.shutdown(immediate=immediate)
+            sinks_to_close = list(self._sinks)
+
+        if immediate:
+            self._dispatcher_task_expected_to_cancel = True
+            self._dispatcher_task.cancel()
+            await asyncio.gather(
+                *(sink.close(immediate=True) for sink in sinks_to_close)
+            )
+        else:
+            # Wait for all already-enqueued events to be dispatched
+            await self._join_incoming_queue()
+            self._dispatcher_task_expected_to_cancel = True
+            self._dispatcher_task.cancel()
+            await asyncio.gather(
+                *(sink.close(immediate=False) for sink in sinks_to_close)
+            )
+
+        # Both branches above cancel the dispatcher task, but the sink gather
+        # only awaits the sinks. Await the cancelled dispatcher here so it is
+        # never left pending when close() returns -- e.g. a source created with
+        # create_default_sink=False and no taps has no sinks for the gather to
+        # await, which would otherwise leave the cancelled dispatcher pending
+        # and trigger "Task was destroyed but it is pending!".
+        #
+        # Suppress the expected CancelledError and any error the dispatcher
+        # raised while shutting down: close() is teardown (reachable from
+        # __aexit__) and must not raise, and _dispatch_loop already logs its own
+        # exceptions, so a dispatcher failure stays observable without
+        # propagating out of close().
+        with contextlib.suppress(asyncio.CancelledError, Exception):
+            await self._dispatcher_task
+
+    def is_closed(self) -> bool:
+        """[DEPRECATED] Checks if the queue is closed.
+
+        NOTE: Relying on this for enqueue logic introduces race conditions.
+        It is maintained primarily for backwards compatibility, workarounds for
+        Python 3.10/3.12 async queues in consumers, and for the test suite.
+        """
+        return self._is_closed
+
+    async def test_only_join_incoming_queue(self) -> None:
+        """Wait for incoming queue to be fully processed."""
+        await self._join_incoming_queue()
+
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager, returning the queue itself.
+
+        WARNING: See `__aexit__` for important deadlock risks associated with
+        exiting this context manager if unconsumed events remain.
+        """
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager, ensuring close() is called.
+
+        WARNING: The context manager calls `close(immediate=False)` by default.
+        If a consumer exits the `async with` block early (e.g., due to an exception
+        or an explicit `break`) while unconsumed events remain in the queue,
+        `__aexit__` will deadlock waiting for `task_done()` to be called on those events.
+        """
+        await self.close()
+
+
+class EventQueueSink(EventQueue):
+    """The Child EventQueue.
+
+    Acts as a read-only consumer endpoint. Events are pushed here exclusively
+    by the parent EventQueueSource's dispatcher task.
+    """
+
+    def __init__(
+        self,
+        parent: EventQueueSource,
+        max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE,
+        evict_on_full: bool = False,
+    ) -> None:
+        """Initializes the EventQueueSink.
+
+        Args:
+            parent: The EventQueueSource this sink belongs to.
+            max_queue_size: Bound for this sink's queue.
+            evict_on_full: Dispatch policy for this sink; see
+                ``EventQueueSource.tap``.
+        """
+        if max_queue_size <= 0:
+            raise ValueError('max_queue_size must be greater than 0')
+
+        self._parent = parent
+        self._evict_on_full = evict_on_full
+        self._queue: AsyncQueue[Event] = create_async_queue(
+            maxsize=max_queue_size
+        )
+        self._is_closed = False
+        self._lock = asyncio.Lock()
+
+        logger.debug('EventQueueSink initialized.')
+
+    @property
+    def queue(self) -> AsyncQueue[Event]:
+        """Returns the underlying asyncio.Queue of this sink."""
+        return self._queue
+
+    async def _put_internal(self, event: Event) -> None:
+        with contextlib.suppress(QueueShutDown):
+            await self._queue.put(event)
+
+    async def enqueue_event(self, event: Event) -> None:
+        """Sinks are read-only and cannot have events directly enqueued to them."""
+        raise RuntimeError('Cannot enqueue to a sink-only queue')
+
+    async def dequeue_event(self) -> Event:
+        """Pulls an event from the sink queue."""
+        logger.debug('Attempting to dequeue event (waiting).')
+        event = await self._queue.get()
+        logger.debug('Dequeued event: %s', event)
+        return event
+
+    def task_done(self) -> None:
+        """Signals that a work on dequeued event is complete in this sink queue."""
+        logger.debug('Marking task as done in EventQueueSink.')
+        self._queue.task_done()
+
+    async def tap(
+        self,
+        max_queue_size: int = DEFAULT_MAX_QUEUE_SIZE,
+        evict_on_full: bool = False,
+    ) -> 'EventQueueSink':
+        """Creates a child queue that receives future events.
+
+        Note: The tapped queue may receive some old events if the incoming event
+        queue is lagging behind and hasn't dispatched them yet.
+        """
+        # Delegate tap to the parent source so all sinks are flat under the source
+        return await self._parent.tap(
+            max_queue_size=max_queue_size, evict_on_full=evict_on_full
+        )
+
+    async def close(self, immediate: bool = False) -> None:
+        """Closes the child sink queue.
+
+        It is safe to call it multiple times.
+        If immediate is True, the queue will be closed without waiting for all events to be processed.
+        If immediate is False, the queue will be closed after all events are processed (and confirmed with task_done() calls).
+        """
+        logger.debug('Closing EventQueueSink.')
+        async with self._lock:
+            self._is_closed = True
+            self._queue.shutdown(immediate=immediate)
+
+        await self._parent.remove_sink(self)
+
+        if not immediate:
+            await self._queue.join()
+
+    def is_closed(self) -> bool:
+        """[DEPRECATED] Checks if the queue is closed.
+
+        NOTE: Relying on this for enqueue logic introduces race conditions.
+        It is maintained primarily for backwards compatibility, workarounds for
+        Python 3.10/3.12 async queues in consumers, and for the test suite.
+        """
+        return self._is_closed
+
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager, returning the queue itself.
+
+        WARNING: See `__aexit__` for important deadlock risks associated with
+        exiting this context manager if unconsumed events remain.
+        """
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager, ensuring close() is called.
+
+        WARNING: The context manager calls `close(immediate=False)` by default.
+        If a consumer exits the `async with` block early (e.g., due to an exception
+        or an explicit `break`) while unconsumed events remain in the queue,
+        `__aexit__` will deadlock waiting for `task_done()` to be called on those events.
+        """
+        await self.close()
diff --git a/src/a2a/server/events/in_memory_queue_manager.py b/src/a2a/server/events/in_memory_queue_manager.py
index 9d4a135be..493ac18ea 100644
--- a/src/a2a/server/events/in_memory_queue_manager.py
+++ b/src/a2a/server/events/in_memory_queue_manager.py
@@ -1,55 +1,85 @@
-import asyncio
+import threading
 
-from a2a.server.events.event_queue import EventQueue
+from a2a.server.events.event_queue import EventQueueLegacy
 from a2a.server.events.queue_manager import (
     NoTaskQueue,
     QueueManager,
     TaskQueueExists,
 )
+from a2a.utils.telemetry import SpanKind, trace_class
 
 
+@trace_class(kind=SpanKind.SERVER)
 class InMemoryQueueManager(QueueManager):
     """InMemoryQueueManager is used for a single binary management.
 
-    This implements the QueueManager but requires all incoming interactions
-    to hit the same binary that manages the queues.
+    This implements the `QueueManager` interface using in-memory storage for event
+    queues. It requires all incoming interactions for a given task ID to hit the
+    same binary instance.
 
-    This works for single binary solution. Needs a distributed approach for
-    true scalable deployment.
+    This implementation is suitable for single-instance deployments but needs
+    a distributed approach for scalable deployments.
     """
 
     def __init__(self) -> None:
-        self._task_queue: dict[str, EventQueue] = {}
-        self._lock = asyncio.Lock()
+        """Initializes the InMemoryQueueManager."""
+        self._task_queue: dict[str, EventQueueLegacy] = {}
+        self._lock = threading.RLock()
 
-    async def add(self, task_id: str, queue: EventQueue):
-        async with self._lock:
+    async def add(self, task_id: str, queue: EventQueueLegacy) -> None:
+        """Adds a new event queue for a task ID.
+
+        Raises:
+            TaskQueueExists: If a queue for the given `task_id` already exists.
+        """
+        with self._lock:
             if task_id in self._task_queue:
-                raise TaskQueueExists()
+                raise TaskQueueExists
             self._task_queue[task_id] = queue
 
-    async def get(self, task_id: str) -> EventQueue | None:
-        async with self._lock:
-            if task_id not in self._task_queue:
-                return None
-            return self._task_queue[task_id]
-
-    async def tap(self, task_id: str) -> EventQueue | None:
-        async with self._lock:
-            if task_id not in self._task_queue:
-                return None
-            return self._task_queue[task_id].tap()
-
-    async def close(self, task_id: str):
-        async with self._lock:
-            if task_id not in self._task_queue:
-                raise NoTaskQueue()
-            del self._task_queue[task_id]
-
-    async def create_or_tap(self, task_id: str) -> EventQueue:
-        async with self._lock:
-            if task_id not in self._task_queue:
-                queue = EventQueue()
+    async def get(self, task_id: str) -> EventQueueLegacy | None:
+        """Retrieves the event queue for a task ID.
+
+        Returns:
+            The `EventQueueLegacy` instance for the `task_id`, or `None` if not found.
+        """
+        with self._lock:
+            return self._task_queue.get(task_id)
+
+    async def tap(self, task_id: str) -> EventQueueLegacy | None:
+        """Taps the event queue for a task ID to create a child queue.
+
+        Returns:
+            A new child `EventQueueLegacy` instance, or `None` if the task ID is not found.
+        """
+        with self._lock:
+            queue = self._task_queue.get(task_id)
+        if queue is None:
+            return None
+        return await queue.tap()
+
+    async def close(self, task_id: str) -> None:
+        """Closes and removes the event queue for a task ID.
+
+        Raises:
+            NoTaskQueue: If no queue exists for the given `task_id`.
+        """
+        with self._lock:
+            queue = self._task_queue.pop(task_id, None)
+        if queue is None:
+            raise NoTaskQueue
+        await queue.close()
+
+    async def create_or_tap(self, task_id: str) -> EventQueueLegacy:
+        """Creates a new event queue for a task ID if one doesn't exist, otherwise taps the existing one.
+
+        Returns:
+            A new or child `EventQueueLegacy` instance for the `task_id`.
+        """
+        with self._lock:
+            queue = self._task_queue.get(task_id)
+            if queue is None:
+                queue = EventQueueLegacy()
                 self._task_queue[task_id] = queue
                 return queue
-            return self._task_queue[task_id].tap()
+        return await queue.tap()
diff --git a/src/a2a/server/events/queue_manager.py b/src/a2a/server/events/queue_manager.py
index bef273f3c..b3ec204a5 100644
--- a/src/a2a/server/events/queue_manager.py
+++ b/src/a2a/server/events/queue_manager.py
@@ -1,35 +1,35 @@
 from abc import ABC, abstractmethod
 
-from a2a.server.events.event_queue import EventQueue
+from a2a.server.events.event_queue import EventQueueLegacy
 
 
 class QueueManager(ABC):
-    """Interface for managing the event queue lifecycles."""
+    """Interface for managing the event queue lifecycles per task."""
 
     @abstractmethod
-    async def add(self, task_id: str, queue: EventQueue):
-        pass
+    async def add(self, task_id: str, queue: EventQueueLegacy) -> None:
+        """Adds a new event queue associated with a task ID."""
 
     @abstractmethod
-    async def get(self, task_id: str) -> EventQueue | None:
-        pass
+    async def get(self, task_id: str) -> EventQueueLegacy | None:
+        """Retrieves the event queue for a task ID."""
 
     @abstractmethod
-    async def tap(self, task_id: str) -> EventQueue | None:
-        pass
+    async def tap(self, task_id: str) -> EventQueueLegacy | None:
+        """Creates a child event queue (tap) for an existing task ID."""
 
     @abstractmethod
-    async def close(self, task_id: str):
-        pass
+    async def close(self, task_id: str) -> None:
+        """Closes and removes the event queue for a task ID."""
 
     @abstractmethod
-    async def create_or_tap(self, task_id: str) -> EventQueue:
-        pass
+    async def create_or_tap(self, task_id: str) -> EventQueueLegacy:
+        """Creates a queue if one doesn't exist, otherwise taps the existing one."""
 
 
-class TaskQueueExists(Exception):
-    pass
+class TaskQueueExists(Exception):  # noqa: N818
+    """Exception raised when attempting to add a queue for a task ID that already exists."""
 
 
-class NoTaskQueue(Exception):
-    pass
+class NoTaskQueue(Exception):  # noqa: N818
+    """Exception raised when attempting to access or close a queue for a task ID that does not exist."""
diff --git a/src/a2a/server/id_generator.py b/src/a2a/server/id_generator.py
new file mode 100644
index 000000000..c523adc97
--- /dev/null
+++ b/src/a2a/server/id_generator.py
@@ -0,0 +1,28 @@
+import uuid
+
+from abc import ABC, abstractmethod
+
+from pydantic import BaseModel
+
+
+class IDGeneratorContext(BaseModel):
+    """Context for providing additional information to ID generators."""
+
+    task_id: str | None = None
+    context_id: str | None = None
+
+
+class IDGenerator(ABC):
+    """Interface for generating unique identifiers."""
+
+    @abstractmethod
+    def generate(self, context: IDGeneratorContext) -> str:
+        pass
+
+
+class UUIDGenerator(IDGenerator):
+    """UUID implementation of the IDGenerator interface."""
+
+    def generate(self, context: IDGeneratorContext) -> str:
+        """Generates a random UUID, ignoring the context."""
+        return str(uuid.uuid4())
diff --git a/src/a2a/server/jsonrpc_models.py b/src/a2a/server/jsonrpc_models.py
new file mode 100644
index 000000000..f5a056282
--- /dev/null
+++ b/src/a2a/server/jsonrpc_models.py
@@ -0,0 +1,56 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+
+class JSONRPCBaseModel(BaseModel):
+    """Base model for JSON-RPC objects."""
+
+    model_config = {
+        'extra': 'allow',
+        'populate_by_name': True,
+        'arbitrary_types_allowed': True,
+    }
+
+
+class JSONRPCError(JSONRPCBaseModel):
+    """Base model for JSON-RPC error objects."""
+
+    code: int
+    message: str
+    data: Any | None = None
+
+
+class JSONParseError(JSONRPCError):
+    """Error raised when invalid JSON was received by the server."""
+
+    code: Literal[-32700] = -32700  # pyright: ignore [reportIncompatibleVariableOverride]
+    message: str = 'Parse error'
+
+
+class InvalidRequestError(JSONRPCError):
+    """Error raised when the JSON sent is not a valid Request object."""
+
+    code: Literal[-32600] = -32600  # pyright: ignore [reportIncompatibleVariableOverride]
+    message: str = 'Invalid Request'
+
+
+class MethodNotFoundError(JSONRPCError):
+    """Error raised when the method does not exist / is not available."""
+
+    code: Literal[-32601] = -32601  # pyright: ignore [reportIncompatibleVariableOverride]
+    message: str = 'Method not found'
+
+
+class InvalidParamsError(JSONRPCError):
+    """Error raised when invalid method parameter(s)."""
+
+    code: Literal[-32602] = -32602  # pyright: ignore [reportIncompatibleVariableOverride]
+    message: str = 'Invalid params'
+
+
+class InternalError(JSONRPCError):
+    """Error raised when internal JSON-RPC error."""
+
+    code: Literal[-32603] = -32603  # pyright: ignore [reportIncompatibleVariableOverride]
+    message: str = 'Internal error'
diff --git a/src/a2a/server/models.py b/src/a2a/server/models.py
new file mode 100644
index 000000000..b296900db
--- /dev/null
+++ b/src/a2a/server/models.py
@@ -0,0 +1,281 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from typing_extensions import override
+else:
+
+    def override(func):  # noqa: ANN001, ANN201
+        """Override decorator."""
+        return func
+
+
+from a2a.types.a2a_pb2 import Artifact, Message, TaskStatus
+
+
+try:
+    from sqlalchemy import (
+        JSON,
+        BigInteger,
+        DateTime,
+        Index,
+        Integer,
+        LargeBinary,
+        String,
+    )
+    from sqlalchemy.orm import (
+        DeclarativeBase,
+        Mapped,
+        declared_attr,
+        mapped_column,
+    )
+except ImportError as e:
+    raise ImportError(
+        'Database models require SQLAlchemy. '
+        'Install with one of: '
+        "'pip install a2a-sdk[postgresql]', "
+        "'pip install a2a-sdk[mysql]', "
+        "'pip install a2a-sdk[sqlite]', "
+        "or 'pip install a2a-sdk[sql]'"
+    ) from e
+
+
+# Base class for all database models
+class Base(DeclarativeBase):
+    """Base class for declarative models in A2A SDK."""
+
+
+# TaskMixin that can be used with any table name
+class TaskMixin:
+    """Mixin providing standard task columns with proper type handling."""
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True, index=True)
+    context_id: Mapped[str] = mapped_column(String(36), nullable=False)
+    kind: Mapped[str] = mapped_column(
+        String(16), nullable=False, default='task'
+    )
+    owner: Mapped[str] = mapped_column(String(255), nullable=True)
+    last_updated: Mapped[datetime | None] = mapped_column(
+        DateTime, nullable=True
+    )
+    status: Mapped[TaskStatus] = mapped_column(JSON, nullable=False)
+    artifacts: Mapped[list[Artifact] | None] = mapped_column(
+        JSON, nullable=True
+    )
+    history: Mapped[list[Message] | None] = mapped_column(JSON, nullable=True)
+    protocol_version: Mapped[str | None] = mapped_column(
+        String(16), nullable=True
+    )
+
+    # Using declared_attr to avoid conflict with Pydantic's metadata
+    @declared_attr
+    @classmethod
+    def task_metadata(cls) -> Mapped[dict[str, Any] | None]:
+        """Define the 'metadata' column, avoiding name conflicts with Pydantic."""
+        return mapped_column(JSON, nullable=True, name='metadata')
+
+    @override
+    def __repr__(self) -> str:
+        """Return a string representation of the task."""
+        return (
+            f'<{self.__class__.__name__}(id="{self.id}", '
+            f'context_id="{self.context_id}", status="{self.status}")>'
+        )
+
+    @declared_attr.directive
+    @classmethod
+    def __table_args__(cls) -> tuple[Any, ...]:
+        """Define a composite index (owner, last_updated) for each table that uses the mixin."""
+        tablename = getattr(cls, '__tablename__', 'tasks')
+        return (
+            Index(
+                f'idx_{tablename}_owner_last_updated', 'owner', 'last_updated'
+            ),
+        )
+
+
+def create_task_model(
+    table_name: str = 'tasks', base: type[DeclarativeBase] = Base
+) -> type:
+    """Create a TaskModel class with a configurable table name.
+
+    Args:
+        table_name: Name of the database table. Defaults to 'tasks'.
+        base: Base declarative class to use. Defaults to the SDK's Base class.
+
+    Returns:
+        TaskModel class with the specified table name.
+
+    Example:
+        .. code-block:: python
+
+            # Create a task model with default table name
+            TaskModel = create_task_model()
+
+            # Create a task model with custom table name
+            CustomTaskModel = create_task_model('my_tasks')
+
+            # Use with a custom base
+            from myapp.database import Base as MyBase
+
+            TaskModel = create_task_model('tasks', MyBase)
+    """
+
+    class TaskModel(TaskMixin, base):  # type: ignore
+        __tablename__ = table_name
+
+        @override
+        def __repr__(self) -> str:
+            """Return a string representation of the task."""
+            return (
+                f'<TaskModel[{table_name}](id="{self.id}", '
+                f'context_id="{self.context_id}", status="{self.status}")>'
+            )
+
+    # Set a dynamic name for better debugging
+    TaskModel.__name__ = f'TaskModel_{table_name}'
+    TaskModel.__qualname__ = f'TaskModel_{table_name}'
+
+    return TaskModel
+
+
+# Default TaskModel for backward compatibility
+class TaskModel(TaskMixin, Base):
+    """Default task model with standard table name."""
+
+    __tablename__ = 'tasks'
+
+
+# PushNotificationConfigMixin that can be used with any table name
+class PushNotificationConfigMixin:
+    """Mixin providing standard push notification config columns."""
+
+    task_id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    config_id: Mapped[str] = mapped_column(String(255), primary_key=True)
+    config_data: Mapped[bytes] = mapped_column(LargeBinary, nullable=False)
+    owner: Mapped[str] = mapped_column(String(255), nullable=True, index=True)
+    protocol_version: Mapped[str | None] = mapped_column(
+        String(16), nullable=True
+    )
+
+    @override
+    def __repr__(self) -> str:
+        """Return a string representation of the push notification config."""
+        return (
+            f'<{self.__class__.__name__}(task_id="{self.task_id}", '
+            f'config_id="{self.config_id}")>'
+        )
+
+
+def create_push_notification_config_model(
+    table_name: str = 'push_notification_configs',
+    base: type[DeclarativeBase] = Base,
+) -> type:
+    """Create a PushNotificationConfigModel class with a configurable table name."""
+
+    class PushNotificationConfigModel(PushNotificationConfigMixin, base):  # type: ignore
+        __tablename__ = table_name
+
+        @override
+        def __repr__(self) -> str:
+            """Return a string representation of the push notification config."""
+            return (
+                f'<PushNotificationConfigModel[{table_name}]('
+                f'task_id="{self.task_id}", config_id="{self.config_id}")>'
+            )
+
+    PushNotificationConfigModel.__name__ = (
+        f'PushNotificationConfigModel_{table_name}'
+    )
+    PushNotificationConfigModel.__qualname__ = (
+        f'PushNotificationConfigModel_{table_name}'
+    )
+
+    return PushNotificationConfigModel
+
+
+# Default PushNotificationConfigModel for backward compatibility
+class PushNotificationConfigModel(PushNotificationConfigMixin, Base):
+    """Default push notification config model with standard table name."""
+
+    __tablename__ = 'push_notification_configs'
+
+
+# TaskEventMixin: append-only log of task events for the clustered event stream.
+class TaskEventMixin:
+    """Mixin providing columns for an append-only task-event log.
+
+    Written transactionally with the task row by the clustered
+    `VersionedTaskStore` and read by `DatabaseTaskEventStream`. Only used by
+    `a2a.server.cluster`; unused by the default single-process stores.
+    """
+
+    seq: Mapped[int] = mapped_column(
+        BigInteger().with_variant(Integer, 'sqlite'),
+        primary_key=True,
+        autoincrement=True,
+    )
+    task_id: Mapped[str] = mapped_column(String(36), nullable=False, index=True)
+    owner: Mapped[str] = mapped_column(String(255), nullable=True)
+    # Task version produced by applying this event.
+    task_version: Mapped[int] = mapped_column(BigInteger, nullable=False)
+    # Serialized StreamResponse proto for the event.
+    event_data: Mapped[bytes] = mapped_column(LargeBinary, nullable=False)
+
+    @override
+    def __repr__(self) -> str:
+        """Return a string representation of the task event."""
+        return (
+            f'<{self.__class__.__name__}(seq={getattr(self, "seq", None)}, '
+            f'task_id="{self.task_id}", task_version={self.task_version})>'
+        )
+
+
+def create_task_event_model(
+    table_name: str = 'task_events', base: type[DeclarativeBase] = Base
+) -> type:
+    """Create a TaskEventModel class with a configurable table name."""
+
+    class TaskEventModel(TaskEventMixin, base):  # type: ignore
+        __tablename__ = table_name
+
+    TaskEventModel.__name__ = f'TaskEventModel_{table_name}'
+    TaskEventModel.__qualname__ = f'TaskEventModel_{table_name}'
+    return TaskEventModel
+
+
+# Default TaskEventModel for backward compatibility.
+class TaskEventModel(TaskEventMixin, Base):
+    """Default task-event model with standard table name."""
+
+    __tablename__ = 'task_events'
+
+
+class TaskVersionMixin:
+    """Mixin providing the compare-and-swap version for a task."""
+
+    task_id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    owner: Mapped[str] = mapped_column(String(255), nullable=True)
+    version: Mapped[int] = mapped_column(BigInteger, nullable=False)
+
+
+def create_task_version_model(
+    table_name: str = 'task_versions',
+    base: type[DeclarativeBase] = Base,
+) -> type:
+    """Create a TaskVersionModel class with a configurable table name."""
+
+    class TaskVersionModel(TaskVersionMixin, base):  # type: ignore
+        __tablename__ = table_name
+
+    TaskVersionModel.__name__ = f'TaskVersionModel_{table_name}'
+    TaskVersionModel.__qualname__ = f'TaskVersionModel_{table_name}'
+    return TaskVersionModel
+
+
+# Default TaskVersionModel for backward compatibility.
+class TaskVersionModel(TaskVersionMixin, Base):
+    """Default task-version model with standard table name."""
+
+    __tablename__ = 'task_versions'
diff --git a/src/a2a/server/owner_resolver.py b/src/a2a/server/owner_resolver.py
new file mode 100644
index 000000000..4fca42d24
--- /dev/null
+++ b/src/a2a/server/owner_resolver.py
@@ -0,0 +1,13 @@
+from collections.abc import Callable
+
+from a2a.server.context import ServerCallContext
+
+
+# Definition
+OwnerResolver = Callable[[ServerCallContext], str]
+
+
+# Example Default Implementation
+def resolve_user_scope(context: ServerCallContext) -> str:
+    """Resolves the owner scope based on the user in the context."""
+    return context.user.user_name
diff --git a/src/a2a/server/request_handlers/__init__.py b/src/a2a/server/request_handlers/__init__.py
index 9b3851cea..054735b0e 100644
--- a/src/a2a/server/request_handlers/__init__.py
+++ b/src/a2a/server/request_handlers/__init__.py
@@ -1,18 +1,59 @@
+"""Request handler components for the A2A server."""
+
+import logging
+
 from a2a.server.request_handlers.default_request_handler import (
-    DefaultRequestHandler,
+    LegacyRequestHandler,
+)
+from a2a.server.request_handlers.default_request_handler_v2 import (
+    DefaultRequestHandlerV2,
+)
+from a2a.server.request_handlers.request_handler import (
+    RequestHandler,
+    validate_request_params,
 )
-from a2a.server.request_handlers.jsonrpc_handler import JSONRPCHandler
-from a2a.server.request_handlers.request_handler import RequestHandler
 from a2a.server.request_handlers.response_helpers import (
     build_error_response,
     prepare_response_object,
 )
 
 
+logger = logging.getLogger(__name__)
+
+try:
+    from a2a.server.request_handlers.grpc_handler import (
+        DefaultGrpcServerCallContextBuilder,
+        GrpcHandler,
+        GrpcServerCallContextBuilder,
+    )
+except ImportError as e:
+    _original_error = e
+    logger.debug(
+        'GrpcHandler not loaded. This is expected if gRPC dependencies are not installed. Error: %s',
+        _original_error,
+    )
+
+    class GrpcHandler:
+        """Placeholder for GrpcHandler when dependencies are not installed."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                'To use GrpcHandler, its dependencies must be installed. '
+                'You can install them with \'pip install "a2a-sdk[grpc]"\''
+            ) from _original_error
+
+
+DefaultRequestHandler = DefaultRequestHandlerV2
+
 __all__ = [
+    'DefaultGrpcServerCallContextBuilder',
     'DefaultRequestHandler',
-    'JSONRPCHandler',
+    'DefaultRequestHandlerV2',
+    'GrpcHandler',
+    'GrpcServerCallContextBuilder',
+    'LegacyRequestHandler',
     'RequestHandler',
     'build_error_response',
     'prepare_response_object',
+    'validate_request_params',
 ]
diff --git a/src/a2a/server/request_handlers/_plugin_hooks.py b/src/a2a/server/request_handlers/_plugin_hooks.py
new file mode 100644
index 000000000..87a68c9ff
--- /dev/null
+++ b/src/a2a/server/request_handlers/_plugin_hooks.py
@@ -0,0 +1,127 @@
+"""Runs `ServerPlugin` hooks around `DefaultRequestHandlerV2` methods."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import inspect
+
+from contextlib import aclosing
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, cast
+
+from a2a.plugins.types import ServerRequest, ServerResponse
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Callable
+
+    from a2a.plugins.manager import PluginManager
+    from a2a.server.context import ServerCallContext
+    from a2a.types.a2a_pb2 import AgentCard
+
+
+class _PluginHost(Protocol):
+    """A request handler that exposes its plugin manager and agent card."""
+
+    @property
+    def plugins(self) -> PluginManager: ...
+
+    @property
+    def agent_card(self) -> AgentCard: ...
+
+
+_F = TypeVar('_F', bound='Callable[..., Any]')
+
+
+def server_plugin_hooks(method: str) -> Callable[[_F], _F]:
+    """Runs `before_handler_run` / `after_handler_run` around a handler method.
+
+    Apply as the outermost decorator, so that validation errors raised by
+    inner decorators also reach `after_handler_run`. When the handler's manager
+    has no server hooks the method runs unchanged.
+
+    Args:
+        method: The method name passed to the hooks, e.g. ``'get_task'``.
+    """
+
+    def decorator(func: _F) -> _F:
+        if inspect.isasyncgenfunction(func):
+
+            @functools.wraps(func)
+            async def stream_wrapper(
+                self: _PluginHost,
+                params: Any,
+                context: ServerCallContext,
+                *args: Any,
+                **kwargs: Any,
+            ) -> AsyncGenerator[Any, None]:
+                plugins = self.plugins
+                if not plugins.has_server_hooks:
+                    async with aclosing(
+                        func(self, params, context, *args, **kwargs)
+                    ) as events:
+                        async for event in events:
+                            yield event
+                    return
+
+                await plugins.before_handler_run(
+                    ServerRequest(method, params, context, self.agent_card)
+                )
+                error: BaseException | None = None
+                try:
+                    async with aclosing(
+                        func(self, params, context, *args, **kwargs)
+                    ) as events:
+                        async for event in events:
+                            await plugins.after_handler_run(
+                                ServerResponse(
+                                    method,
+                                    event,
+                                    context,
+                                    is_stream_event=True,
+                                    is_final=False,
+                                )
+                            )
+                            yield event
+                except (Exception, asyncio.CancelledError) as e:
+                    error = e
+                    raise
+                finally:
+                    # Also runs when the client disconnects (aclose()).
+                    await plugins.after_handler_run(
+                        ServerResponse(method, None, context, error=error)
+                    )
+
+            return cast('_F', stream_wrapper)
+
+        @functools.wraps(func)
+        async def unary_wrapper(
+            self: _PluginHost,
+            params: Any,
+            context: ServerCallContext,
+            *args: Any,
+            **kwargs: Any,
+        ) -> Any:
+            plugins = self.plugins
+            if not plugins.has_server_hooks:
+                return await func(self, params, context, *args, **kwargs)
+
+            await plugins.before_handler_run(
+                ServerRequest(method, params, context, self.agent_card)
+            )
+            try:
+                result = await func(self, params, context, *args, **kwargs)
+            except (Exception, asyncio.CancelledError) as e:
+                # A cancelled call still gets its after call, as streams do.
+                await plugins.after_handler_run(
+                    ServerResponse(method, None, context, error=e)
+                )
+                raise
+            await plugins.after_handler_run(
+                ServerResponse(method, result, context)
+            )
+            return result
+
+        return cast('_F', unary_wrapper)
+
+    return decorator
diff --git a/src/a2a/server/request_handlers/default_request_handler.py b/src/a2a/server/request_handlers/default_request_handler.py
index f656e4146..166c3d439 100644
--- a/src/a2a/server/request_handlers/default_request_handler.py
+++ b/src/a2a/server/request_handlers/default_request_handler.py
@@ -1,85 +1,252 @@
 import asyncio
-import contextlib
 import logging
-from collections.abc import AsyncGenerator
+import threading
+
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import cast
 
-from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.agent_execution import (
+    AgentExecutor,
+    RequestContext,
+    RequestContextBuilder,
+    SimpleRequestContextBuilder,
+)
+from a2a.server.context import ServerCallContext
 from a2a.server.events import (
     Event,
     EventConsumer,
-    EventQueue,
+    EventQueueLegacy,
     InMemoryQueueManager,
-    NoTaskQueue,
     QueueManager,
-    TaskQueueExists,
 )
-from a2a.server.request_handlers.request_handler import RequestHandler
-from a2a.server.tasks import ResultAggregator, TaskManager, TaskStore
-from a2a.types import (
-    InternalError,
+from a2a.server.request_handlers.request_handler import (
+    RequestHandler,
+    validate,
+    validate_request_params,
+)
+from a2a.server.tasks import (
+    PushNotificationConfigStore,
+    PushNotificationEvent,
+    PushNotificationSender,
+    ResultAggregator,
+    TaskManager,
+    TaskStore,
+)
+from a2a.server.tasks.push_notification_config_store import (
+    normalize_push_notification_config,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
     Message,
-    MessageSendParams,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
     Task,
-    TaskIdParams,
-    TaskNotFoundError,
     TaskPushNotificationConfig,
-    TaskQueryParams,
+    TaskState,
+)
+from a2a.utils.constants import TERMINAL_TASK_STATES
+from a2a.utils.errors import (
+    ExtendedAgentCardNotConfiguredError,
+    InternalError,
+    InvalidParamsError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
     UnsupportedOperationError,
 )
-from a2a.utils.errors import ServerError
+from a2a.utils.input_mode_validator import validate_input_modes
+from a2a.utils.proto_utils import warn_on_missing_required_fields
+from a2a.utils.task import (
+    apply_history_length,
+    validate_history_length,
+    validate_page_size,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
+
 
 logger = logging.getLogger(__name__)
 
 
-class DefaultRequestHandler(RequestHandler):
-    """Default request handler for all incoming requests."""
+@trace_class(kind=SpanKind.SERVER)
+class LegacyRequestHandler(RequestHandler):
+    """Default request handler for all incoming requests.
+
+    This handler provides default implementations for all A2A JSON-RPC methods,
+    coordinating between the `AgentExecutor`, `TaskStore`, `QueueManager`,
+    and optional `PushNotifier`.
+    """
 
     _running_agents: dict[str, asyncio.Task]
+    _background_tasks: set[asyncio.Task]
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         agent_executor: AgentExecutor,
         task_store: TaskStore,
+        agent_card: AgentCard,
         queue_manager: QueueManager | None = None,
+        push_config_store: PushNotificationConfigStore | None = None,
+        push_sender: PushNotificationSender | None = None,
+        request_context_builder: RequestContextBuilder | None = None,
+        extended_agent_card: AgentCard | None = None,
+        extended_card_modifier: Callable[
+            [AgentCard, ServerCallContext], Awaitable[AgentCard]
+        ]
+        | None = None,
+        push_url_validator: Callable[[str], Awaitable[bool]] | None = None,
+        validate_input_modes: bool = False,
     ) -> None:
+        """Initializes the DefaultRequestHandler.
+
+        Args:
+            agent_executor: The `AgentExecutor` instance to run agent logic.
+            task_store: The `TaskStore` instance to manage task persistence.
+            agent_card: The `AgentCard` describing the agent's capabilities.
+            queue_manager: The `QueueManager` instance to manage event queues. Defaults to `InMemoryQueueManager`.
+            push_config_store: The `PushNotificationConfigStore` instance for managing push notification configurations. Defaults to None.
+            push_sender: The `PushNotificationSender` instance for sending push notifications. Defaults to None.
+            request_context_builder: The `RequestContextBuilder` instance used
+              to build request contexts. Defaults to `SimpleRequestContextBuilder`.
+            extended_agent_card: An optional, distinct `AgentCard` to be served at the extended card endpoint.
+            extended_card_modifier: An optional callback to dynamically modify the extended `AgentCard` before it is served.
+            push_url_validator: Async callable that returns True to accept
+              a push URL, or False to reject it. Defaults to None (no
+              library screening). The spec lists these checks as SHOULD,
+              so deployments that want the built-in policy should pass
+              ``validate_push_notification_url``.
+            validate_input_modes: Reject message parts whose ``media_type``
+              the card declares nowhere -- neither in
+              ``default_input_modes`` nor in any skill's ``input_modes`` --
+              with ``ContentTypeNotSupportedError``. Defaults to False,
+              because an agent whose declared modes do not spell the media
+              types its clients really send would start refusing traffic it
+              previously accepted.
+        """
         self.agent_executor = agent_executor
         self.task_store = task_store
+        self._agent_card = agent_card
         self._queue_manager = queue_manager or InMemoryQueueManager()
+        self._push_config_store = push_config_store
+        self._push_sender = push_sender
+        self._push_url_validator = push_url_validator
+        self._validate_input_modes = validate_input_modes
+        self.extended_agent_card = extended_agent_card
+        self.extended_card_modifier = extended_card_modifier
+        warn_on_missing_required_fields(
+            agent_card, 'agent_card passed to DefaultRequestHandler:'
+        )
+        if extended_agent_card is not None:
+            warn_on_missing_required_fields(
+                extended_agent_card,
+                'extended_agent_card passed to DefaultRequestHandler:',
+            )
+        self._request_context_builder = (
+            request_context_builder
+            or SimpleRequestContextBuilder(
+                should_populate_referred_tasks=False, task_store=self.task_store
+            )
+        )
         # TODO: Likely want an interface for managing this, like AgentExecutionManager.
         self._running_agents = {}
-        self._running_agents_lock = asyncio.Lock()
+        self._running_agents_lock = threading.RLock()
+        # Tracks background tasks (e.g., deferred cleanups) to avoid orphaning
+        # asyncio tasks and to surface unexpected exceptions.
+        self._background_tasks = set()
+
+    async def _reject_unsafe_push_url(self, url: str) -> None:
+        """Apply the configured push-URL policy, if any."""
+        if self._push_url_validator is None:
+            return
+        if not await self._push_url_validator(url):
+            raise InvalidParamsError(message='Invalid push notification URL')
 
-    async def on_get_task(self, params: TaskQueryParams) -> Task | None:
+    @validate_request_params
+    async def on_get_task(
+        self,
+        params: GetTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
         """Default handler for 'tasks/get'."""
-        task: Task | None = await self.task_store.get(params.id)
+        validate_history_length(params)
+
+        task_id = params.id
+        task: Task | None = await self.task_store.get(task_id, context)
         if not task:
-            raise ServerError(error=TaskNotFoundError())
-        return task
+            raise TaskNotFoundError
+
+        return apply_history_length(task, params)
+
+    @validate_request_params
+    async def on_list_tasks(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Default handler for 'tasks/list'."""
+        validate_history_length(params)
+        if params.HasField('page_size'):
+            validate_page_size(params.page_size)
+
+        page = await self.task_store.list(params, context)
+        for task in page.tasks:
+            if not params.include_artifacts:
+                task.ClearField('artifacts')
+
+            updated_task = apply_history_length(task, params)
+            if updated_task is not task:
+                task.CopyFrom(updated_task)
+
+        return page
+
+    @validate_request_params
+    async def on_cancel_task(
+        self,
+        params: CancelTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
+        """Default handler for 'tasks/cancel'.
 
-    async def on_cancel_task(self, params: TaskIdParams) -> Task | None:
-        """Default handler for 'tasks/cancel'."""
-        task: Task | None = await self.task_store.get(params.id)
+        Attempts to cancel the task managed by the `AgentExecutor`.
+        """
+        task_id = params.id
+        task: Task | None = await self.task_store.get(task_id, context)
         if not task:
-            raise ServerError(error=TaskNotFoundError())
+            raise TaskNotFoundError
+
+        # Check if task is in a non-cancelable state (completed, canceled, failed, rejected)
+        if task.status.state in TERMINAL_TASK_STATES:
+            raise TaskNotCancelableError(
+                message=f'Task cannot be canceled - current state: {TaskState.Name(task.status.state)}'
+            )
 
         task_manager = TaskManager(
             task_id=task.id,
-            context_id=task.contextId,
+            context_id=task.context_id,
             task_store=self.task_store,
             initial_message=None,
+            context=context,
         )
         result_aggregator = ResultAggregator(task_manager)
 
         queue = await self._queue_manager.tap(task.id)
         if not queue:
-            queue = EventQueue()
+            queue = EventQueueLegacy()
 
         await self.agent_executor.cancel(
             RequestContext(
-                None,
+                call_context=context,
+                request=params,
                 task_id=task.id,
-                context_id=task.contextId,
+                context_id=task.context_id,
                 task=task,
             ),
             queue,
@@ -90,165 +257,500 @@ async def on_cancel_task(self, params: TaskIdParams) -> Task | None:
 
         consumer = EventConsumer(queue)
         result = await result_aggregator.consume_all(consumer)
-        if isinstance(result, Task):
-            return result
+        if not isinstance(result, Task):
+            raise InternalError(
+                message='Agent did not return valid response for cancel'
+            )
 
-        raise ServerError(
-            error=InternalError(message='Agent did not result valid response')
-        )
+        if result.status.state != TaskState.TASK_STATE_CANCELED:
+            raise TaskNotCancelableError(
+                message=f'Task cannot be canceled - current state: {TaskState.Name(result.status.state)}'
+            )
+
+        return result
 
     async def _run_event_stream(
-        self, request: RequestContext, queue: EventQueue
+        self, request: RequestContext, queue: EventQueueLegacy
     ) -> None:
+        """Runs the agent's `execute` method and closes the queue afterwards.
+
+        Args:
+            request: The request context for the agent.
+            queue: The event queue for the agent to publish to.
+        """
         await self.agent_executor.execute(request, queue)
-        queue.close()
+        await queue.close()
 
-    async def on_message_send(
-        self, params: MessageSendParams
-    ) -> Message | Task:
-        """Default handler for 'message/send' interface."""
+    async def _setup_message_execution(
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> tuple[
+        TaskManager, str, EventQueueLegacy, ResultAggregator, asyncio.Task
+    ]:
+        """Common setup logic for both streaming and non-streaming message handling.
+
+        Returns:
+            A tuple of (task_manager, task_id, queue, result_aggregator, producer_task)
+        """
+        if self._validate_input_modes:
+            validate_input_modes(params.message, self._agent_card)
+
+        # Create task manager and validate existing task
+        # Proto empty strings should be treated as None
+        task_id = params.message.task_id or None
+        context_id = params.message.context_id or None
         task_manager = TaskManager(
-            task_id=params.message.taskId,
-            context_id=params.message.contextId,
+            task_id=task_id,
+            context_id=context_id,
             task_store=self.task_store,
             initial_message=params.message,
+            context=context,
         )
         task: Task | None = await task_manager.get_task()
+
         if task:
+            if task.status.state in TERMINAL_TASK_STATES:
+                raise UnsupportedOperationError(
+                    message=f'Task {task.id} is in terminal state: {TaskState.Name(task.status.state)}'
+                )
+
             task = task_manager.update_with_message(params.message, task)
-        request_context = RequestContext(
-            params,
-            task.id if task else None,
-            task.contextId if task else None,
-            task,
+            # Agents must infer the contextId from the task when the message
+            # names only a taskId.
+            context_id = context_id or task.context_id
+        elif params.message.task_id:
+            raise TaskNotFoundError(
+                message=f'Task {params.message.task_id} was specified but does not exist'
+            )
+
+        # Build request context
+        request_context = await self._request_context_builder.build(
+            params=params,
+            task_id=task.id if task else None,
+            context_id=context_id,
+            task=task,
+            context=context,
         )
-        task_id = cast(str, request_context.task_id)
+
+        task_id = cast('str', request_context.task_id)
         # Always assign a task ID. We may not actually upgrade to a task, but
         # dictating the task ID at this layer is useful for tracking running
         # agents.
+
+        if self._push_config_store and params.configuration.HasField(
+            'task_push_notification_config'
+        ):
+            await self._reject_unsafe_push_url(
+                params.configuration.task_push_notification_config.url
+            )
+            await self._push_config_store.set_info(
+                task_id,
+                params.configuration.task_push_notification_config,
+                context,
+            )
+
         queue = await self._queue_manager.create_or_tap(task_id)
         result_aggregator = ResultAggregator(task_manager)
-        # TODO to manage the non-blocking flows.
+        # TODO: to manage the non-blocking flows.
         producer_task = asyncio.create_task(
-            self._run_event_stream(
-                request_context,
-                queue,
-            )
+            self._run_event_stream(request_context, queue)
         )
         await self._register_producer(task_id, producer_task)
 
+        return task_manager, task_id, queue, result_aggregator, producer_task
+
+    def _validate_task_id_match(self, task_id: str, event_task_id: str) -> None:
+        """Validates that agent-generated task ID matches the expected task ID."""
+        if task_id != event_task_id:
+            logger.error(
+                'Agent generated task_id=%s does not match the RequestContext task_id=%s.',
+                event_task_id,
+                task_id,
+            )
+            raise InternalError(message='Task ID mismatch in agent response')
+
+    async def _send_push_notification_if_needed(
+        self, task_id: str, event: Event
+    ) -> None:
+        """Sends push notification if configured."""
+        if (
+            self._push_sender
+            and task_id
+            and isinstance(event, PushNotificationEvent)
+        ):
+            try:
+                await self._push_sender.send_notification(task_id, event)
+            except Exception:
+                # Push delivery is best-effort: a sender failure must not
+                # fail the task or disturb the event stream.
+                logger.exception(
+                    'Push notification sender raised for task_id=%s; '
+                    'ignoring the failure.',
+                    task_id,
+                )
+
+    @validate_request_params
+    async def on_message_send(
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> Message | Task:
+        """Default handler for 'message/send' interface (non-streaming).
+
+        Starts the agent execution for the message and waits for the final
+        result (Task or Message).
+        """
+        validate_history_length(params.configuration)
+
+        (
+            _task_manager,
+            task_id,
+            queue,
+            result_aggregator,
+            producer_task,
+        ) = await self._setup_message_execution(params, context)
+
         consumer = EventConsumer(queue)
+        producer_task.add_done_callback(consumer.agent_task_callback)
+
+        blocking = not params.configuration.return_immediately
 
-        interrupted = False
+        interrupted_or_non_blocking = False
         try:
+            # Create async callback for push notifications
+            async def push_notification_callback(event: Event) -> None:
+                await self._send_push_notification_if_needed(task_id, event)
+
             (
                 result,
-                interrupted,
-            ) = await result_aggregator.consume_and_break_on_interrupt(consumer)
-            if not result:
-                raise ServerError(error=InternalError())
+                interrupted_or_non_blocking,
+                bg_consume_task,
+            ) = await result_aggregator.consume_and_break_on_interrupt(
+                consumer,
+                blocking=blocking,
+                event_callback=push_notification_callback,
+            )
+
+            if bg_consume_task is not None:
+                bg_consume_task.set_name(f'continue_consuming:{task_id}')
+                self._track_background_task(bg_consume_task)
+
+        except Exception:
+            logger.exception('Agent execution failed')
+            producer_task.cancel()
+            raise
         finally:
-            if interrupted:
-                # TODO: Track this disconnected cleanup task.
-                asyncio.create_task(
+            if interrupted_or_non_blocking:
+                cleanup_task = asyncio.create_task(
                     self._cleanup_producer(producer_task, task_id)
                 )
+                cleanup_task.set_name(f'cleanup_producer:{task_id}')
+                self._track_background_task(cleanup_task)
             else:
                 await self._cleanup_producer(producer_task, task_id)
 
+        if not result:
+            raise InternalError
+
+        if isinstance(result, Task):
+            self._validate_task_id_match(task_id, result.id)
+            if params.configuration:
+                result = apply_history_length(result, params.configuration)
+
         return result
 
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.streaming,
+        'Streaming is not supported by the agent',
+    )
     async def on_message_send_stream(
-        self, params: MessageSendParams
-    ) -> AsyncGenerator[Event, None]:
-        """Default handler for 'message/stream'."""
-        task_manager = TaskManager(
-            task_id=params.message.taskId,
-            context_id=params.message.contextId,
-            task_store=self.task_store,
-            initial_message=params.message,
-        )
-        task: Task | None = await task_manager.get_task()
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event]:
+        """Default handler for 'message/stream' (streaming).
 
-        if task:
-            task = task_manager.update_with_message(params.message, task)
+        Starts the agent execution and yields events as they are produced
+        by the agent.
+        """
+        validate_history_length(params.configuration)
 
-        result_aggregator = ResultAggregator(task_manager)
-        request_context = RequestContext(
-            params,
-            task.id if task else None,
-            task.contextId if task else None,
-            task,
-        )
-        task_id = cast(str, request_context.task_id)
-        queue = await self._queue_manager.create_or_tap(task_id)
-        producer_task = asyncio.create_task(
-            self._run_event_stream(
-                request_context,
-                queue,
-            )
-        )
-        await self._register_producer(task_id, producer_task)
+        (
+            _task_manager,
+            task_id,
+            queue,
+            result_aggregator,
+            producer_task,
+        ) = await self._setup_message_execution(params, context)
+        consumer = EventConsumer(queue)
+        producer_task.add_done_callback(consumer.agent_task_callback)
 
         try:
-            consumer = EventConsumer(queue)
             async for event in result_aggregator.consume_and_emit(consumer):
-                # Now we know we have a Task, register the queue
+                response = event
                 if isinstance(event, Task):
-                    try:
-                        await self._queue_manager.add(event.id, queue)
-                        task_id = event.id
-                    except TaskQueueExists:
-                        logging.info(
-                            'Multiple Task objects created in event stream.'
-                        )
-                yield event
+                    self._validate_task_id_match(task_id, event.id)
+                    response = apply_history_length(event, params.configuration)
+
+                await self._send_push_notification_if_needed(task_id, event)
+                yield response
+        except (asyncio.CancelledError, GeneratorExit):
+            # Client disconnected: continue consuming and persisting events in the background
+            bg_task = asyncio.create_task(
+                result_aggregator.consume_all(consumer)
+            )
+            bg_task.set_name(f'background_consume:{task_id}')
+            self._track_background_task(bg_task)
+            raise
         finally:
-            await self._cleanup_producer(producer_task, task_id)
+            cleanup_task = asyncio.create_task(
+                self._cleanup_producer(producer_task, task_id)
+            )
+            cleanup_task.set_name(f'cleanup_producer:{task_id}')
+            self._track_background_task(cleanup_task)
 
-    async def _register_producer(self, task_id, producer_task):
-        async with self._running_agents_lock:
+    async def _register_producer(
+        self, task_id: str, producer_task: asyncio.Task
+    ) -> None:
+        """Registers the agent execution task with the handler."""
+        with self._running_agents_lock:
             self._running_agents[task_id] = producer_task
 
-    async def _cleanup_producer(self, producer_task, task_id):
-        await producer_task
+    def _track_background_task(self, task: asyncio.Task) -> None:
+        """Tracks a background task and logs exceptions on completion.
+
+        This avoids unreferenced tasks (and associated lint warnings) while
+        ensuring any exceptions are surfaced in logs.
+        """
+        self._background_tasks.add(task)
+
+        def _on_done(completed: asyncio.Task) -> None:
+            try:
+                # Retrieve result to raise exceptions, if any
+                completed.result()
+            except asyncio.CancelledError:
+                name = completed.get_name()
+                logger.debug('Background task %s cancelled', name)
+            except Exception:
+                name = completed.get_name()
+                logger.exception('Background task %s failed', name)
+            finally:
+                self._background_tasks.discard(completed)
+
+        task.add_done_callback(_on_done)
+
+    async def _cleanup_producer(
+        self,
+        producer_task: asyncio.Task,
+        task_id: str,
+    ) -> None:
+        """Cleans up the agent execution task and queue manager entry."""
+        try:
+            await producer_task
+        except asyncio.CancelledError:
+            logger.debug(
+                'Producer task %s was cancelled during cleanup', task_id
+            )
         await self._queue_manager.close(task_id)
-        async with self._running_agents_lock:
+        with self._running_agents_lock:
             self._running_agents.pop(task_id, None)
 
-    async def on_set_task_push_notification_config(
-        self, params: TaskPushNotificationConfig
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_create_task_push_notification_config(
+        self,
+        params: TaskPushNotificationConfig,
+        context: ServerCallContext,
     ) -> TaskPushNotificationConfig:
-        """Default handler for 'tasks/pushNotificationConfig/set'."""
-        raise ServerError(error=UnsupportedOperationError())
+        """Default handler for 'tasks/pushNotificationConfig/create'.
+
+        Requires a `PushNotifier` to be configured.
+        """
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
 
+        task_id = params.task_id
+        task: Task | None = await self.task_store.get(task_id, context)
+        if not task:
+            raise TaskNotFoundError
+
+        await self._reject_unsafe_push_url(params.url)
+
+        stored = await self._push_config_store.set_info(
+            task_id,
+            params,
+            context,
+        )
+        if stored is not None:
+            return stored
+        # Custom stores written before set_info returned the stored config.
+        return normalize_push_notification_config(task_id, params)
+
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
     async def on_get_task_push_notification_config(
-        self, params: TaskIdParams
+        self,
+        params: GetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
     ) -> TaskPushNotificationConfig:
-        """Default handler for 'tasks/pushNotificationConfig/get'."""
-        raise ServerError(error=UnsupportedOperationError())
+        """Default handler for 'tasks/pushNotificationConfig/get'.
+
+        Requires a `PushConfigStore` to be configured.
+        """
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        config_id = params.id
+        task: Task | None = await self.task_store.get(task_id, context)
+        if not task:
+            raise TaskNotFoundError
+
+        push_notification_configs: list[TaskPushNotificationConfig] = (
+            await self._push_config_store.get_info(task_id, context) or []
+        )
+
+        for config in push_notification_configs:
+            if config.id == config_id:
+                return config
+
+        raise TaskNotFoundError
 
-    async def on_resubscribe_to_task(
-        self, params: TaskIdParams
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.streaming,
+        'Streaming is not supported by the agent',
+    )
+    async def on_subscribe_to_task(
+        self,
+        params: SubscribeToTaskRequest,
+        context: ServerCallContext,
     ) -> AsyncGenerator[Event, None]:
-        """Default handler for 'tasks/resubscribe'."""
-        task: Task | None = await self.task_store.get(params.id)
+        """Default handler for 'SubscribeToTask'.
+
+        Allows a client to re-attach to a running streaming task's event stream.
+        Requires the task and its queue to still be active.
+        """
+        task_id = params.id
+        task: Task | None = await self.task_store.get(task_id, context)
         if not task:
-            raise ServerError(error=TaskNotFoundError())
+            raise TaskNotFoundError
+
+        if task.status.state in TERMINAL_TASK_STATES:
+            raise UnsupportedOperationError(
+                message=f'Task {task.id} is in terminal state: {TaskState.Name(task.status.state)}'
+            )
+
+        # The operation MUST return a Task object as the first event in the stream
+        # https://a2a-protocol.org/latest/specification/#316-subscribe-to-task
+        yield task
 
         task_manager = TaskManager(
             task_id=task.id,
-            context_id=task.contextId,
+            context_id=task.context_id,
             task_store=self.task_store,
             initial_message=None,
+            context=context,
         )
 
         result_aggregator = ResultAggregator(task_manager)
 
         queue = await self._queue_manager.tap(task.id)
         if not queue:
-            raise ServerError(error=TaskNotFoundError())
+            raise TaskNotFoundError
 
         consumer = EventConsumer(queue)
         async for event in result_aggregator.consume_and_emit(consumer):
             yield event
+
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_list_task_push_notification_configs(
+        self,
+        params: ListTaskPushNotificationConfigsRequest,
+        context: ServerCallContext,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Default handler for 'ListTaskPushNotificationConfigs'.
+
+        Requires a `PushConfigStore` to be configured.
+        """
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        task: Task | None = await self.task_store.get(task_id, context)
+        if not task:
+            raise TaskNotFoundError
+
+        push_notification_config_list = await self._push_config_store.get_info(
+            task_id, context
+        )
+
+        return ListTaskPushNotificationConfigsResponse(
+            configs=push_notification_config_list
+        )
+
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_delete_task_push_notification_config(
+        self,
+        params: DeleteTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> None:
+        """Default handler for 'tasks/pushNotificationConfig/delete'.
+
+        Requires a `PushConfigStore` to be configured.
+        """
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        config_id = params.id
+        task: Task | None = await self.task_store.get(task_id, context)
+        if not task:
+            raise TaskNotFoundError
+
+        await self._push_config_store.delete_info(task_id, context, config_id)
+
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.extended_agent_card,
+        error_message='The agent does not support authenticated extended cards',
+    )
+    async def on_get_extended_agent_card(
+        self,
+        params: GetExtendedAgentCardRequest,
+        context: ServerCallContext,
+    ) -> AgentCard:
+        """Default handler for 'GetExtendedAgentCard'.
+
+        Requires `capabilities.extended_agent_card` to be true.
+        """
+        extended_card = self.extended_agent_card
+        if not extended_card:
+            raise ExtendedAgentCardNotConfiguredError
+
+        if self.extended_card_modifier:
+            extended_card = await self.extended_card_modifier(
+                extended_card, context
+            )
+
+        return extended_card
diff --git a/src/a2a/server/request_handlers/default_request_handler_v2.py b/src/a2a/server/request_handlers/default_request_handler_v2.py
new file mode 100644
index 000000000..e66e4208c
--- /dev/null
+++ b/src/a2a/server/request_handlers/default_request_handler_v2.py
@@ -0,0 +1,792 @@
+from __future__ import annotations
+
+import asyncio  # noqa: TC003
+import logging
+import warnings
+
+from contextlib import aclosing
+from typing import TYPE_CHECKING, Any, cast
+
+from a2a.plugins.manager import get_global
+from a2a.plugins.types import TaskEventInfo
+from a2a.server.agent_execution import (
+    AgentExecutor,
+    RequestContext,
+    RequestContextBuilder,
+    SimpleRequestContextBuilder,
+)
+from a2a.server.agent_execution.active_task_registry import ActiveTaskRegistry
+from a2a.server.agent_execution.plugin_agent_executor import (
+    PluginAgentExecutor,
+)
+from a2a.server.cluster.event_stream import (
+    VersionedEvent,
+    _stream_accepts_context,
+)
+from a2a.server.cluster.task_store import (
+    ConcurrentTaskModificationError,
+    LegacyTaskStoreAdapter,
+    VersionedTaskStore,
+)
+from a2a.server.request_handlers._plugin_hooks import server_plugin_hooks
+from a2a.server.request_handlers.request_handler import (
+    RequestHandler,
+    validate,
+    validate_request_params,
+)
+from a2a.server.tasks.push_notification_config_store import (
+    normalize_push_notification_config,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import (
+    INTERRUPTED_TASK_STATES,
+    TERMINAL_TASK_STATES,
+)
+from a2a.utils.errors import (
+    ExtendedAgentCardNotConfiguredError,
+    InternalError,
+    InvalidAgentResponseError,
+    InvalidParamsError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from a2a.utils.input_mode_validator import validate_input_modes
+from a2a.utils.proto_utils import warn_on_missing_required_fields
+from a2a.utils.task import (
+    apply_history_length,
+    validate_history_length,
+    validate_page_size,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Awaitable, Callable
+
+    from a2a.plugins.manager import PluginManager
+    from a2a.server.agent_execution.active_task import ActiveTask
+    from a2a.server.cluster.event_stream import TaskEventStream
+    from a2a.server.cluster.version import TaskVersion
+    from a2a.server.context import ServerCallContext
+    from a2a.server.events import Event
+    from a2a.server.tasks import (
+        PushNotificationConfigStore,
+        PushNotificationSender,
+        TaskStore,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+@trace_class(kind=SpanKind.SERVER)
+class DefaultRequestHandlerV2(RequestHandler):
+    """Default request handler for all incoming requests.
+
+    The ``queue_manager`` parameter is accepted for signature compatibility
+    with `DefaultRequestHandler` but is not used: v2 delegates event streaming
+    to an in-memory `ActiveTaskRegistry`. Passing a non-``None`` value emits a
+    `DeprecationWarning` and logs a warning.
+
+    ``interrupted_task_timeout`` releases the `ActiveTask` of a task idle in
+    ``input-required`` or ``auth-required`` after that many seconds; a
+    follow-up recreates it from the store. ``None`` (default) never releases;
+    any other value must be greater than 0.
+
+    ``plugins`` selects the plugin manager whose hooks run for this handler.
+    It defaults to the global manager (`a2a.plugins.get_global()`) at
+    construction time.
+    """
+
+    _background_tasks: set[asyncio.Task]
+
+    def __init__(  # noqa: PLR0913
+        self,
+        agent_executor: AgentExecutor,
+        task_store: TaskStore | VersionedTaskStore,
+        agent_card: AgentCard,
+        queue_manager: Any
+        | None = None,  # Accepted for signature compat; ignored in v2 (warns)
+        push_config_store: PushNotificationConfigStore | None = None,
+        push_sender: PushNotificationSender | None = None,
+        request_context_builder: RequestContextBuilder | None = None,
+        extended_agent_card: AgentCard | None = None,
+        extended_card_modifier: Callable[
+            [AgentCard, ServerCallContext], Awaitable[AgentCard]
+        ]
+        | None = None,
+        push_url_validator: Callable[[str], Awaitable[bool]] | None = None,
+        validate_input_modes: bool = False,
+        event_stream: TaskEventStream | None = None,
+        interrupted_task_timeout: float | None = None,
+        plugins: PluginManager | None = None,
+    ) -> None:
+        if (
+            interrupted_task_timeout is not None
+            and interrupted_task_timeout <= 0
+        ):
+            raise ValueError('interrupted_task_timeout must be greater than 0.')
+        if queue_manager is not None:
+            message = (
+                'A queue_manager was passed to DefaultRequestHandlerV2, but it '
+                'is not used: v2 delegates event streaming to an in-memory '
+                'ActiveTaskRegistry, so custom or distributed QueueManager '
+                'implementations are ignored. For multi-replica event '
+                'streaming, either use LegacyRequestHandler or route '
+                'subscription requests to the replica holding the task.'
+            )
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            logger.warning(message)
+        self._plugins: PluginManager = (
+            plugins if plugins is not None else get_global()
+        )
+        self.agent_executor = agent_executor
+        self.task_store: TaskStore | VersionedTaskStore = task_store
+        self._versioned_store: VersionedTaskStore = (
+            task_store
+            if isinstance(task_store, VersionedTaskStore)
+            else LegacyTaskStoreAdapter(task_store)
+        )
+        self._agent_card = agent_card
+        self._push_config_store = push_config_store
+        self._push_sender = push_sender
+        self._push_url_validator = push_url_validator
+        self._validate_input_modes = validate_input_modes
+        self.extended_agent_card = extended_agent_card
+        self.extended_card_modifier = extended_card_modifier
+        self._event_stream = event_stream
+        if isinstance(task_store, VersionedTaskStore) and event_stream is None:
+            message = (
+                'A VersionedTaskStore was configured without an event_stream, '
+                'so cross-replica streaming is disabled'
+            )
+            warnings.warn(message, stacklevel=2)
+            logger.warning(message)
+        warn_on_missing_required_fields(
+            agent_card, 'agent_card passed to DefaultRequestHandlerV2:'
+        )
+        if extended_agent_card is not None:
+            warn_on_missing_required_fields(
+                extended_agent_card,
+                'extended_agent_card passed to DefaultRequestHandlerV2:',
+            )
+        self._request_context_builder = (
+            request_context_builder
+            or SimpleRequestContextBuilder(
+                should_populate_referred_tasks=False,
+                task_store=None,
+            )
+        )
+        self._active_task_registry = ActiveTaskRegistry(
+            agent_executor=(
+                PluginAgentExecutor(agent_executor, self._plugins)
+                if self._plugins.has_execution_hooks
+                else agent_executor
+            ),
+            task_store=self._versioned_store,
+            push_sender=self._push_sender,
+            event_stream=self._event_stream,
+            interrupted_task_timeout=interrupted_task_timeout,
+            plugins=self._plugins,
+        )
+        self._background_tasks = set()
+
+    @property
+    def plugins(self) -> PluginManager:
+        """The plugin manager whose hooks run for this handler."""
+        return self._plugins
+
+    @property
+    def agent_card(self) -> AgentCard:
+        """The agent card served by this handler."""
+        return self._agent_card
+
+    async def _reject_unsafe_push_url(self, url: str) -> None:
+        """Apply the configured push-URL policy, if any."""
+        if self._push_url_validator is None:
+            return
+        if not await self._push_url_validator(url):
+            raise InvalidParamsError(message='Invalid push notification URL')
+
+    async def aclose(self) -> None:
+        """Shuts down the handler, draining all active tasks.
+
+        Drains the ``ActiveTaskRegistry`` so a server shutdown leaves no
+        pending ``asyncio.Task``. Intended to be wired into an ASGI
+        ``lifespan`` / ``on_shutdown`` hook. Safe to call multiple times.
+        """
+        await self._active_task_registry.aclose()
+
+    @server_plugin_hooks('get_task')
+    @validate_request_params
+    async def on_get_task(  # noqa: D102
+        self,
+        params: GetTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
+        validate_history_length(params)
+
+        task_id = params.id
+        stored = await self._versioned_store.get(task_id, context)
+        if stored is None:
+            raise TaskNotFoundError
+
+        return apply_history_length(stored.task, params)
+
+    @server_plugin_hooks('list_tasks')
+    @validate_request_params
+    async def on_list_tasks(  # noqa: D102
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        validate_history_length(params)
+        if params.HasField('page_size'):
+            validate_page_size(params.page_size)
+
+        page = await self._versioned_store.list(params, context)
+        for task in page.tasks:
+            if not params.include_artifacts:
+                task.ClearField('artifacts')
+
+            updated_task = apply_history_length(task, params)
+            if updated_task is not task:
+                task.CopyFrom(updated_task)
+
+        return page
+
+    @server_plugin_hooks('cancel_task')
+    @validate_request_params
+    async def on_cancel_task(  # noqa: D102
+        self,
+        params: CancelTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
+        task_id = params.id
+
+        # Owner-scoped read of the current state
+        stored = await self._versioned_store.get(task_id, context)
+        if stored is None:
+            raise TaskNotFoundError
+        task, version = stored.task, stored.version
+
+        # Terminal tasks, including already cancelled ones, are not cancelable.
+        if task.status.state in TERMINAL_TASK_STATES:
+            raise TaskNotCancelableError
+
+        # This replica holds the task, running or waiting for input.
+        if await self._active_task_registry.get(task_id) is not None:
+            return await self._cancel_local(params, context)
+
+        # Running on another replica (or nowhere): record CANCELED in shared
+        # state; the owner sees the version bump on its next save and aborts.
+        return await self._cancel_remote(task_id, task, version, context)
+
+    async def _cancel_local(
+        self, params: CancelTaskRequest, context: ServerCallContext
+    ) -> Task:
+        try:
+            active_task = await self._active_task_registry.get_or_create(
+                params.id, call_context=context, create_task_if_missing=False
+            )
+            try:
+                result = await active_task.cancel(context, request=params)
+            finally:
+                # get_or_create stopped the timer; a failed cancel leaves the task parked.
+                active_task.schedule_idle_release()
+        except UnsupportedOperationError as e:
+            raise TaskNotCancelableError from e
+
+        if isinstance(result, Message):
+            raise InternalError(
+                message='Cancellation returned a message instead of a task.'
+            )
+
+        return result
+
+    async def _cancel_remote(
+        self,
+        task_id: str,
+        task: Task,
+        version: TaskVersion,
+        context: ServerCallContext,
+    ) -> Task:
+        try:
+            return await self._write_cancel(task_id, task, version, context)
+        except ConcurrentTaskModificationError:
+            reloaded_stored = await self._versioned_store.get(task_id, context)
+            if reloaded_stored is None:
+                raise TaskNotFoundError from None
+            if (
+                reloaded_stored.task.status.state
+                == TaskState.TASK_STATE_CANCELED
+            ):
+                return reloaded_stored.task
+            raise TaskNotCancelableError from None
+
+    async def _write_cancel(
+        self,
+        task_id: str,
+        current: Task,
+        version: TaskVersion,
+        context: ServerCallContext,
+    ) -> Task:
+        cancelled = Task()
+        cancelled.CopyFrom(current)
+        cancelled.status.state = TaskState.TASK_STATE_CANCELED
+        event = TaskStatusUpdateEvent(
+            task_id=task_id,
+            context_id=current.context_id,
+            status=cancelled.status,
+        )
+        new_version = await self._versioned_store.save(
+            cancelled,
+            event=event,
+            prev=current,
+            prev_version=version,
+            context=context,
+        )
+        if self._plugins.has_task_hooks:
+            # Remote cancel writes the store directly, bypassing TaskManager.
+            await self._plugins.on_task_event(
+                TaskEventInfo(
+                    task_id=task_id,
+                    from_state=current.status.state,
+                    to_state=cancelled.status.state,
+                    event=event,
+                    task=cancelled,
+                    context=context,
+                )
+            )
+        if self._event_stream is not None:
+            versioned_event = VersionedEvent(event=event, version=new_version)
+            if _stream_accepts_context(self._event_stream, 'publish'):
+                # TODO(ISSUE #1374): remove this check once ServerCallContext is a required parameter on TaskEventStream.
+                await self._event_stream.publish(
+                    task_id,
+                    versioned_event,
+                    context=context,  # ty:ignore[unknown-argument]
+                )
+            else:
+                await self._event_stream.publish(task_id, versioned_event)
+        return cancelled
+
+    def _validate_task_id_match(self, task_id: str, event_task_id: str) -> None:
+        if task_id != event_task_id:
+            logger.error(
+                'Agent generated task_id=%s does not match the RequestContext task_id=%s.',
+                event_task_id,
+                task_id,
+            )
+            raise InternalError(message='Task ID mismatch in agent response')
+
+    async def _setup_active_task(
+        self,
+        params: SendMessageRequest,
+        call_context: ServerCallContext,
+    ) -> tuple[ActiveTask, RequestContext]:
+        validate_history_length(params.configuration)
+        if self._validate_input_modes:
+            validate_input_modes(params.message, self._agent_card)
+
+        original_task_id = params.message.task_id or None
+        original_context_id = params.message.context_id or None
+
+        if original_task_id:
+            stored = await self._versioned_store.get(
+                original_task_id, call_context
+            )
+            if stored is None:
+                raise TaskNotFoundError(f'Task {original_task_id} not found')
+            task = stored.task
+            # Agents must reject a message whose contextId differs from that
+            # of the task it names.
+            if original_context_id and task.context_id != original_context_id:
+                raise InvalidParamsError(
+                    message=(
+                        f'Context {original_context_id} does not match '
+                        f'context {task.context_id} of task {original_task_id}'
+                    )
+                )
+            # Agents must infer the contextId from the task when the message
+            # names only a taskId.
+            original_context_id = original_context_id or task.context_id
+
+        # Build context to resolve or generate missing IDs
+        request_context = await self._request_context_builder.build(
+            params=params,
+            task_id=original_task_id,
+            context_id=original_context_id,
+            # We will get the task when we have to process the request to avoid concurrent read/write issues.
+            task=None,
+            context=call_context,
+        )
+
+        task_id = cast('str', request_context.task_id)
+        context_id = cast('str', request_context.context_id)
+
+        if self._push_config_store and params.configuration.HasField(
+            'task_push_notification_config'
+        ):
+            await self._reject_unsafe_push_url(
+                params.configuration.task_push_notification_config.url
+            )
+            await self._push_config_store.set_info(
+                task_id,
+                params.configuration.task_push_notification_config,
+                call_context,
+            )
+
+        active_task = await self._active_task_registry.get_or_create(
+            task_id,
+            context_id=context_id,
+            call_context=call_context,
+            create_task_if_missing=True,
+            initial_message=request_context.message,
+        )
+
+        return active_task, request_context
+
+    @server_plugin_hooks('send_message')
+    @validate_request_params
+    async def on_message_send(  # noqa: D102
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> Message | Task:
+        active_task, request_context = await self._setup_active_task(
+            params, context
+        )
+        task_id = cast('str', request_context.task_id)
+
+        result: Message | Task | None = None
+
+        async for raw_event in active_task.subscribe(
+            request=request_context,
+            include_initial_task=False,
+            replace_status_update_with_task=True,
+        ):
+            event = raw_event
+            logger.debug(
+                'Processing[%s] event [%s] %s',
+                params.message.task_id,
+                type(event).__name__,
+                event,
+            )
+            if isinstance(event, Task) and (
+                params.configuration.return_immediately
+                or event.status.state
+                in (TERMINAL_TASK_STATES | INTERRUPTED_TASK_STATES)
+            ):
+                self._validate_task_id_match(task_id, event.id)
+                result = event
+                # A FAILED task may be followed by a producer exception. Keep
+                # the task as the fallback result, but let the subscription
+                # surface that exception or finish the current request.
+                if (
+                    params.configuration.return_immediately
+                    or event.status.state != TaskState.TASK_STATE_FAILED
+                ):
+                    # AgentExecutor will continue to run in the background
+                    # when return_immediately is set.
+                    break
+
+            if isinstance(event, Message):
+                result = event
+                # Do NOT break here as Message is supposed to be the only
+                # event in "Message-only" interaction.
+                # ActiveTask consumer (see active_task.py) validates the event
+                # stream and raises InvalidAgentResponseError if more events are
+                # pushed after a Message.
+
+        if result is None:
+            if not active_task.task_created:
+                # A silent executor means get_task() would block forever.
+                raise InvalidAgentResponseError(
+                    message='Agent execution produced no events'
+                )
+            logger.debug('Missing result for task %s', request_context.task_id)
+            result = await active_task.get_task()
+
+        if isinstance(result, Task):
+            result = apply_history_length(result, params.configuration)
+
+        logger.debug(
+            'Returning result for task %s: %s',
+            request_context.task_id,
+            result,
+        )
+        return result
+
+    @server_plugin_hooks('send_message_streaming')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.streaming,
+        'Streaming is not supported by the agent',
+    )
+    async def on_message_send_stream(  # noqa: D102
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event, None]:
+        active_task, request_context = await self._setup_active_task(
+            params, context
+        )
+
+        task_id = cast('str', request_context.task_id)
+
+        async for event in active_task.subscribe(
+            request=request_context,
+            include_initial_task=False,
+        ):
+            # Do NOT break here as we rely on AgentExecutor to yield control.
+            # ActiveTask consumer (see active_task.py) validates the event
+            # stream and raises InvalidAgentResponseError on misbehaving agents:
+            #   - an event after a Message
+            #   - Message after entering task mode
+            #   - an event after a terminal state
+            if isinstance(event, Task):
+                self._validate_task_id_match(task_id, event.id)
+                yield apply_history_length(event, params.configuration)
+            else:
+                yield event
+
+    @server_plugin_hooks('create_task_push_notification_config')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_create_task_push_notification_config(  # noqa: D102
+        self,
+        params: TaskPushNotificationConfig,
+        context: ServerCallContext,
+    ) -> TaskPushNotificationConfig:
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        if await self._versioned_store.get(task_id, context) is None:
+            raise TaskNotFoundError
+
+        await self._reject_unsafe_push_url(params.url)
+
+        stored = await self._push_config_store.set_info(
+            task_id,
+            params,
+            context,
+        )
+        if stored is not None:
+            return stored
+        # Custom stores written before set_info returned the stored config.
+        return normalize_push_notification_config(task_id, params)
+
+    @server_plugin_hooks('get_task_push_notification_config')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_get_task_push_notification_config(  # noqa: D102
+        self,
+        params: GetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> TaskPushNotificationConfig:
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        config_id = params.id
+        if await self._versioned_store.get(task_id, context) is None:
+            raise TaskNotFoundError
+
+        push_notification_configs: list[TaskPushNotificationConfig] = (
+            await self._push_config_store.get_info(task_id, context) or []
+        )
+
+        for config in push_notification_configs:
+            if config.id == config_id:
+                return config
+
+        raise TaskNotFoundError
+
+    @server_plugin_hooks('subscribe')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.streaming,
+        'Streaming is not supported by the agent',
+    )
+    async def on_subscribe_to_task(  # noqa: D102
+        self,
+        params: SubscribeToTaskRequest,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event, None]:
+        task_id = params.id
+
+        stored = await self._versioned_store.get(task_id, context)
+        if stored is None:
+            raise TaskNotFoundError
+        task, snapshot_version = stored.task, stored.version
+
+        # A terminal task cannot be resubscribed to (nothing further to stream).
+        if task.status.state in TERMINAL_TASK_STATES:
+            raise UnsupportedOperationError(
+                message=f'Task {task_id} is in terminal state: '
+                f'{TaskState.Name(task.status.state)}'
+            )
+
+        if self._event_stream is None:
+            # Single-process mode
+            active = await self._active_task_registry.get_or_create(
+                task_id, call_context=context, create_task_if_missing=False
+            )
+            async for event in active.subscribe(include_initial_task=True):
+                yield event
+            return
+
+        # Shared-stream mode. Fast path: this replica runs the agent -> tap it.
+        stream = self._event_stream
+        local = await self._active_task_registry.get(task_id)
+        if local is not None:
+            async for event in local.subscribe(include_initial_task=True):
+                yield event
+            return
+
+        # Not running here: serve the snapshot and tail the remote stream.
+        async for event in self._subscribe_remote(
+            task_id, task, snapshot_version, stream, context
+        ):
+            yield event
+
+    async def _subscribe_remote(
+        self,
+        task_id: str,
+        task: Task,
+        snapshot_version: TaskVersion,
+        stream: TaskEventStream,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event, None]:
+        """Serves a resubscription for a task running on another replica."""
+        yield task
+
+        if _stream_accepts_context(stream, 'subscribe'):
+            # TODO(ISSUE #1374): remove this check once ServerCallContext is a required parameter on TaskEventStream.
+            subscription_gen = stream.subscribe(
+                task_id,
+                after=snapshot_version,
+                context=context,  # ty:ignore[unknown-argument]
+            )
+        else:
+            subscription_gen = stream.subscribe(task_id, after=snapshot_version)
+
+        async with aclosing(subscription_gen) as subscription:
+            async for versioned in subscription:
+                if not versioned.version.is_after(snapshot_version):
+                    continue
+                event = versioned.event
+                yield event
+                # Stop tailing once the stream ends: a Message, or a status
+                # update / Task in a terminal or interrupted state.
+                if isinstance(event, Message) or (
+                    isinstance(event, TaskStatusUpdateEvent | Task)
+                    and event.status.state
+                    in (TERMINAL_TASK_STATES | INTERRUPTED_TASK_STATES)
+                ):
+                    return
+
+    @server_plugin_hooks('list_task_push_notification_configs')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_list_task_push_notification_configs(  # noqa: D102
+        self,
+        params: ListTaskPushNotificationConfigsRequest,
+        context: ServerCallContext,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        if await self._versioned_store.get(task_id, context) is None:
+            raise TaskNotFoundError
+
+        push_notification_config_list = await self._push_config_store.get_info(
+            task_id, context
+        )
+
+        return ListTaskPushNotificationConfigsResponse(
+            configs=push_notification_config_list
+        )
+
+    @server_plugin_hooks('delete_task_push_notification_config')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.push_notifications,
+        error_message='Push notifications are not supported by the agent',
+        error_type=PushNotificationNotSupportedError,
+    )
+    async def on_delete_task_push_notification_config(  # noqa: D102
+        self,
+        params: DeleteTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> None:
+        if not self._push_config_store:
+            raise PushNotificationNotSupportedError
+
+        task_id = params.task_id
+        config_id = params.id
+        if await self._versioned_store.get(task_id, context) is None:
+            raise TaskNotFoundError
+
+        await self._push_config_store.delete_info(task_id, context, config_id)
+
+    @server_plugin_hooks('get_extended_agent_card')
+    @validate_request_params
+    @validate(
+        lambda self: self._agent_card.capabilities.extended_agent_card,
+        error_message='The agent does not support authenticated extended cards',
+    )
+    async def on_get_extended_agent_card(
+        self,
+        params: GetExtendedAgentCardRequest,
+        context: ServerCallContext,
+    ) -> AgentCard:
+        """Default handler for 'GetExtendedAgentCard'.
+
+        Requires `capabilities.extended_agent_card` to be true.
+        """
+        extended_card = self.extended_agent_card
+        if not extended_card:
+            raise ExtendedAgentCardNotConfiguredError
+
+        if self.extended_card_modifier:
+            extended_card = await self.extended_card_modifier(
+                extended_card, context
+            )
+
+        return extended_card
diff --git a/src/a2a/server/request_handlers/grpc_handler.py b/src/a2a/server/request_handlers/grpc_handler.py
new file mode 100644
index 000000000..d4d8ed669
--- /dev/null
+++ b/src/a2a/server/request_handlers/grpc_handler.py
@@ -0,0 +1,428 @@
+# ruff: noqa: N802
+import logging
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterable, Awaitable, Callable
+from typing import TypeVar
+
+
+try:
+    import grpc  # type: ignore[reportMissingModuleSource]
+    import grpc.aio  # type: ignore[reportMissingModuleSource]
+except ImportError as e:
+    raise ImportError(
+        'GrpcHandler requires grpcio and grpcio-tools to be installed. '
+        'Install with: '
+        "'pip install a2a-sdk[grpc]'"
+    ) from e
+
+from google.protobuf import any_pb2, empty_pb2, message
+from google.rpc import error_details_pb2, status_pb2
+
+import a2a.types.a2a_pb2_grpc as a2a_grpc
+
+from a2a import types
+from a2a.auth.user import UnauthenticatedUser, User
+from a2a.extensions.common import (
+    HTTP_EXTENSION_HEADER,
+    get_requested_extensions,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.types import a2a_pb2
+from a2a.utils import proto_utils
+from a2a.utils.errors import A2A_ERROR_REASONS, A2AError, TaskNotFoundError
+from a2a.utils.grpc_status import status_to_grpc
+from a2a.utils.proto_utils import validation_errors_to_bad_request
+
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcServerCallContextBuilder(ABC):
+    """Interface for building ServerCallContext from gRPC context."""
+
+    @abstractmethod
+    def build(self, context: grpc.aio.ServicerContext) -> ServerCallContext:
+        """Builds a ServerCallContext from a gRPC ServicerContext."""
+
+
+class DefaultGrpcServerCallContextBuilder(GrpcServerCallContextBuilder):
+    """Default implementation of GrpcServerCallContextBuilder."""
+
+    def build(self, context: grpc.aio.ServicerContext) -> ServerCallContext:
+        """Builds a ServerCallContext from a gRPC ServicerContext."""
+        state = {'grpc_context': context}
+        return ServerCallContext(
+            user=self.build_user(context),
+            state=state,
+            requested_extensions=get_requested_extensions(
+                _get_metadata_value(context, HTTP_EXTENSION_HEADER)
+            ),
+        )
+
+    def build_user(self, context: grpc.aio.ServicerContext) -> User:
+        """Builds a User from a gRPC ServicerContext."""
+        return UnauthenticatedUser()
+
+
+def _get_metadata_value(
+    context: grpc.aio.ServicerContext, key: str
+) -> list[str]:
+    md = context.invocation_metadata()
+    if md is None:
+        return []
+
+    lower_key = key.lower()
+    return [
+        e if isinstance(e, str) else e.decode('utf-8')
+        for k, e in md
+        if k.lower() == lower_key
+    ]
+
+
+_ERROR_CODE_MAP: dict[type[A2AError], grpc.StatusCode] = {
+    types.InvalidRequestError: grpc.StatusCode.INVALID_ARGUMENT,
+    types.MethodNotFoundError: grpc.StatusCode.NOT_FOUND,
+    types.InvalidParamsError: grpc.StatusCode.INVALID_ARGUMENT,
+    types.InternalError: grpc.StatusCode.INTERNAL,
+    types.TaskNotFoundError: grpc.StatusCode.NOT_FOUND,
+    types.TaskNotCancelableError: grpc.StatusCode.FAILED_PRECONDITION,
+    types.PushNotificationNotSupportedError: grpc.StatusCode.FAILED_PRECONDITION,
+    types.UnsupportedOperationError: grpc.StatusCode.FAILED_PRECONDITION,
+    types.ContentTypeNotSupportedError: grpc.StatusCode.INVALID_ARGUMENT,
+    types.InvalidAgentResponseError: grpc.StatusCode.INTERNAL,
+    types.ExtendedAgentCardNotConfiguredError: grpc.StatusCode.FAILED_PRECONDITION,
+    types.ExtensionSupportRequiredError: grpc.StatusCode.FAILED_PRECONDITION,
+    types.VersionNotSupportedError: grpc.StatusCode.FAILED_PRECONDITION,
+}
+
+
+TResponse = TypeVar('TResponse')
+
+
+class GrpcHandler(a2a_grpc.A2AServiceServicer):
+    """Maps incoming gRPC requests to the appropriate request handler method."""
+
+    def __init__(
+        self,
+        request_handler: RequestHandler,
+        context_builder: GrpcServerCallContextBuilder | None = None,
+    ):
+        """Initializes the GrpcHandler.
+
+        Args:
+            request_handler: The underlying `RequestHandler` instance to
+                             delegate requests to.
+            context_builder: The GrpcContextBuilder used to construct the
+              ServerCallContext passed to the request_handler. If None the
+              DefaultGrpcContextBuilder is used.
+        """
+        self.request_handler = request_handler
+        self._context_builder = (
+            context_builder or DefaultGrpcServerCallContextBuilder()
+        )
+
+    async def _handle_unary(
+        self,
+        request: message.Message,
+        context: grpc.aio.ServicerContext,
+        handler_func: Callable[[ServerCallContext], Awaitable[TResponse]],
+        default_response: TResponse,
+    ) -> TResponse:
+        """Centralized error handling and context management for unary calls."""
+        try:
+            server_context = self._build_call_context(context, request)
+            result = await handler_func(server_context)
+        except A2AError as e:
+            await self.abort_context(e, context)
+        else:
+            return result
+        return default_response
+
+    async def _handle_stream(
+        self,
+        request: message.Message,
+        context: grpc.aio.ServicerContext,
+        handler_func: Callable[[ServerCallContext], AsyncIterable[TResponse]],
+    ) -> AsyncIterable[TResponse]:
+        """Centralized error handling and context management for streaming calls."""
+        try:
+            server_context = self._build_call_context(context, request)
+            async for item in handler_func(server_context):
+                yield item
+        except A2AError as e:
+            await self.abort_context(e, context)
+
+    async def SendMessage(
+        self,
+        request: a2a_pb2.SendMessageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.SendMessageResponse:
+        """Handles the 'SendMessage' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.SendMessageResponse:
+            task_or_message = await self.request_handler.on_message_send(
+                request, server_context
+            )
+            if isinstance(task_or_message, a2a_pb2.Task):
+                return a2a_pb2.SendMessageResponse(task=task_or_message)
+            return a2a_pb2.SendMessageResponse(message=task_or_message)
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.SendMessageResponse()
+        )
+
+    async def SendStreamingMessage(
+        self,
+        request: a2a_pb2.SendMessageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> AsyncIterable[a2a_pb2.StreamResponse]:
+        """Handles the 'StreamMessage' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> AsyncIterable[a2a_pb2.StreamResponse]:
+            async for event in self.request_handler.on_message_send_stream(
+                request, server_context
+            ):
+                yield proto_utils.to_stream_response(event)
+
+        async for item in self._handle_stream(request, context, _handler):
+            yield item
+
+    async def CancelTask(
+        self,
+        request: a2a_pb2.CancelTaskRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.Task:
+        """Handles the 'CancelTask' gRPC method."""
+
+        async def _handler(server_context: ServerCallContext) -> a2a_pb2.Task:
+            task = await self.request_handler.on_cancel_task(
+                request, server_context
+            )
+            if task:
+                return task
+            raise TaskNotFoundError
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.Task()
+        )
+
+    async def SubscribeToTask(
+        self,
+        request: a2a_pb2.SubscribeToTaskRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> AsyncIterable[a2a_pb2.StreamResponse]:
+        """Handles the 'SubscribeToTask' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> AsyncIterable[a2a_pb2.StreamResponse]:
+            async for event in self.request_handler.on_subscribe_to_task(
+                request, server_context
+            ):
+                yield proto_utils.to_stream_response(event)
+
+        async for item in self._handle_stream(request, context, _handler):
+            yield item
+
+    async def GetTaskPushNotificationConfig(
+        self,
+        request: a2a_pb2.GetTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.TaskPushNotificationConfig:
+        """Handles the 'GetTaskPushNotificationConfig' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.TaskPushNotificationConfig:
+            return (
+                await self.request_handler.on_get_task_push_notification_config(
+                    request, server_context
+                )
+            )
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.TaskPushNotificationConfig()
+        )
+
+    async def CreateTaskPushNotificationConfig(
+        self,
+        request: a2a_pb2.TaskPushNotificationConfig,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.TaskPushNotificationConfig:
+        """Handles the 'CreateTaskPushNotificationConfig' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.TaskPushNotificationConfig:
+            return await self.request_handler.on_create_task_push_notification_config(
+                request, server_context
+            )
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.TaskPushNotificationConfig()
+        )
+
+    async def ListTaskPushNotificationConfigs(
+        self,
+        request: a2a_pb2.ListTaskPushNotificationConfigsRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.ListTaskPushNotificationConfigsResponse:
+        """Handles the 'ListTaskPushNotificationConfig' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.ListTaskPushNotificationConfigsResponse:
+            return await self.request_handler.on_list_task_push_notification_configs(
+                request, server_context
+            )
+
+        return await self._handle_unary(
+            request,
+            context,
+            _handler,
+            a2a_pb2.ListTaskPushNotificationConfigsResponse(),
+        )
+
+    async def DeleteTaskPushNotificationConfig(
+        self,
+        request: a2a_pb2.DeleteTaskPushNotificationConfigRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> empty_pb2.Empty:
+        """Handles the 'DeleteTaskPushNotificationConfig' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> empty_pb2.Empty:
+            await self.request_handler.on_delete_task_push_notification_config(
+                request, server_context
+            )
+            return empty_pb2.Empty()
+
+        return await self._handle_unary(
+            request, context, _handler, empty_pb2.Empty()
+        )
+
+    async def GetTask(
+        self,
+        request: a2a_pb2.GetTaskRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.Task:
+        """Handles the 'GetTask' gRPC method."""
+
+        async def _handler(server_context: ServerCallContext) -> a2a_pb2.Task:
+            task = await self.request_handler.on_get_task(
+                request, server_context
+            )
+            if task:
+                return task
+            raise TaskNotFoundError
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.Task()
+        )
+
+    async def ListTasks(
+        self,
+        request: a2a_pb2.ListTasksRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.ListTasksResponse:
+        """Handles the 'ListTasks' gRPC method."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.ListTasksResponse:
+            return await self.request_handler.on_list_tasks(
+                request, server_context
+            )
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.ListTasksResponse()
+        )
+
+    async def GetExtendedAgentCard(
+        self,
+        request: a2a_pb2.GetExtendedAgentCardRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> a2a_pb2.AgentCard:
+        """Get the extended agent card for the agent served."""
+
+        async def _handler(
+            server_context: ServerCallContext,
+        ) -> a2a_pb2.AgentCard:
+            return await self.request_handler.on_get_extended_agent_card(
+                request, server_context
+            )
+
+        return await self._handle_unary(
+            request, context, _handler, a2a_pb2.AgentCard()
+        )
+
+    async def abort_context(
+        self, error: A2AError, context: grpc.aio.ServicerContext
+    ) -> None:
+        """Sets the grpc errors appropriately in the context."""
+        code = _ERROR_CODE_MAP.get(type(error))
+
+        if code:
+            reason = A2A_ERROR_REASONS.get(type(error), 'UNKNOWN_ERROR')
+            error_info = error_details_pb2.ErrorInfo(
+                reason=reason,
+                domain='a2a-protocol.org',
+            )
+
+            status_code = code.value[0]
+            error_msg = (
+                error.message if hasattr(error, 'message') else str(error)
+            )
+
+            # Create standard Status with ErrorInfo for all A2A errors
+            status = status_pb2.Status(code=status_code, message=error_msg)
+            error_info_detail = any_pb2.Any()
+            error_info_detail.Pack(error_info)
+            status.details.append(error_info_detail)
+
+            # Append structured field violations for validation errors
+            if (
+                isinstance(error, types.InvalidParamsError)
+                and error.data
+                and error.data.get('errors')
+            ):
+                bad_request_detail = any_pb2.Any()
+                bad_request_detail.Pack(
+                    validation_errors_to_bad_request(error.data['errors'])
+                )
+                status.details.append(bad_request_detail)
+
+            rich_status = status_to_grpc(status)
+
+            new_metadata: list[tuple[str, str | bytes]] = []
+            trailing = context.trailing_metadata()
+            if trailing:
+                for k, v in trailing:
+                    new_metadata.append((str(k), v))
+
+            for k, v in rich_status.trailing_metadata:
+                new_metadata.append((str(k), v))
+
+            context.set_trailing_metadata(tuple(new_metadata))
+            await context.abort(rich_status.code, rich_status.details)
+        else:
+            await context.abort(
+                grpc.StatusCode.UNKNOWN,
+                f'Unknown error type: {error}',
+            )
+
+    def _build_call_context(
+        self,
+        context: grpc.aio.ServicerContext,
+        request: message.Message,
+    ) -> ServerCallContext:
+        server_context = self._context_builder.build(context)
+        server_context.tenant = getattr(request, 'tenant', '')
+        return server_context
diff --git a/src/a2a/server/request_handlers/jsonrpc_handler.py b/src/a2a/server/request_handlers/jsonrpc_handler.py
deleted file mode 100644
index d3192f599..000000000
--- a/src/a2a/server/request_handlers/jsonrpc_handler.py
+++ /dev/null
@@ -1,234 +0,0 @@
-import logging
-
-from collections.abc import AsyncIterable
-
-from a2a.server.request_handlers.request_handler import RequestHandler
-from a2a.server.request_handlers.response_helpers import prepare_response_object
-from a2a.types import (
-    AgentCard,
-    CancelTaskRequest,
-    CancelTaskResponse,
-    CancelTaskSuccessResponse,
-    GetTaskPushNotificationConfigRequest,
-    GetTaskPushNotificationConfigResponse,
-    GetTaskPushNotificationConfigSuccessResponse,
-    GetTaskRequest,
-    GetTaskResponse,
-    GetTaskSuccessResponse,
-    InternalError,
-    JSONRPCErrorResponse,
-    Message,
-    SendMessageRequest,
-    SendMessageResponse,
-    SendMessageSuccessResponse,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
-    SendStreamingMessageSuccessResponse,
-    SetTaskPushNotificationConfigRequest,
-    SetTaskPushNotificationConfigResponse,
-    SetTaskPushNotificationConfigSuccessResponse,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskNotFoundError,
-    TaskPushNotificationConfig,
-    TaskResubscriptionRequest,
-    TaskStatusUpdateEvent,
-)
-from a2a.utils.errors import ServerError
-from a2a.utils.helpers import validate
-
-
-logger = logging.getLogger(__name__)
-
-
-class JSONRPCHandler:
-    """A handler that maps the JSONRPC Objects to the request handler and back."""
-
-    def __init__(
-        self,
-        agent_card: AgentCard,
-        request_handler: RequestHandler,
-    ):
-        """Initializes the HttpProducer.
-
-        Args:
-            agent_card: The AgentCard describing the agent's capabilities.
-            request_handler: The handler instance responsible for processing A2A requests.
-        """
-        self.agent_card = agent_card
-        self.request_handler = request_handler
-
-    # message/send
-    async def on_message_send(
-        self, request: SendMessageRequest
-    ) -> SendMessageResponse:
-        # TODO: Wrap in error handler to return error states
-        try:
-            task_or_message = await self.request_handler.on_message_send(
-                request.params
-            )
-            return prepare_response_object(
-                request.id,
-                task_or_message,
-                (Task, Message),
-                SendMessageSuccessResponse,
-                SendMessageResponse,
-            )
-        except ServerError as e:
-            return SendMessageResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # message/stream
-    @validate(
-        lambda self: self.agent_card.capabilities.streaming,
-        'Streaming is not supported by the agent',
-    )
-    async def on_message_send_stream(
-        self, request: SendStreamingMessageRequest
-    ) -> AsyncIterable[SendStreamingMessageResponse]:
-        try:
-            async for event in self.request_handler.on_message_send_stream(
-                request.params
-            ):
-                yield prepare_response_object(
-                    request.id,
-                    event,
-                    (
-                        Task,
-                        Message,
-                        TaskArtifactUpdateEvent,
-                        TaskStatusUpdateEvent,
-                    ),
-                    SendStreamingMessageSuccessResponse,
-                    SendStreamingMessageResponse,
-                )
-        except ServerError as e:
-            yield SendStreamingMessageResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # tasks/cancel
-    async def on_cancel_task(
-        self, request: CancelTaskRequest
-    ) -> CancelTaskResponse:
-        try:
-            task = await self.request_handler.on_cancel_task(request.params)
-            if task:
-                return prepare_response_object(
-                    request.id,
-                    task,
-                    (Task,),
-                    CancelTaskSuccessResponse,
-                    CancelTaskResponse,
-                )
-            raise ServerError(error=TaskNotFoundError())
-        except ServerError as e:
-            return CancelTaskResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # tasks/resubscribe
-    async def on_resubscribe_to_task(
-        self, request: TaskResubscriptionRequest
-    ) -> AsyncIterable[SendStreamingMessageResponse]:
-        try:
-            async for event in self.request_handler.on_resubscribe_to_task(
-                request.params
-            ):
-                yield prepare_response_object(
-                    request.id,
-                    event,
-                    (
-                        Task,
-                        Message,
-                        TaskArtifactUpdateEvent,
-                        TaskStatusUpdateEvent,
-                    ),
-                    SendStreamingMessageSuccessResponse,
-                    SendStreamingMessageResponse,
-                )
-        except ServerError as e:
-            yield SendStreamingMessageResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # tasks/pushNotification/get
-    async def get_push_notification(
-        self, request: GetTaskPushNotificationConfigRequest
-    ) -> GetTaskPushNotificationConfigResponse:
-        try:
-            config = (
-                await self.request_handler.on_get_task_push_notification_config(
-                    request.params
-                )
-            )
-            return prepare_response_object(
-                request.id,
-                config,
-                (TaskPushNotificationConfig,),
-                GetTaskPushNotificationConfigSuccessResponse,
-                GetTaskPushNotificationConfigResponse,
-            )
-        except ServerError as e:
-            return GetTaskPushNotificationConfigResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # tasks/pushNotification/set
-    @validate(
-        lambda self: self.agent_card.capabilities.pushNotifications,
-        'Push notifications are not supported by the agent',
-    )
-    async def set_push_notification(
-        self, request: SetTaskPushNotificationConfigRequest
-    ) -> SetTaskPushNotificationConfigResponse:
-        try:
-            config = (
-                await self.request_handler.on_set_task_push_notification_config(
-                    request.params
-                )
-            )
-            return prepare_response_object(
-                request.id,
-                config,
-                (TaskPushNotificationConfig,),
-                SetTaskPushNotificationConfigSuccessResponse,
-                SetTaskPushNotificationConfigResponse,
-            )
-        except ServerError as e:
-            return SetTaskPushNotificationConfigResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
-
-    # tasks/get
-    async def on_get_task(self, request: GetTaskRequest) -> GetTaskResponse:
-        try:
-            task = await self.request_handler.on_get_task(request.params)
-            if task:
-                return prepare_response_object(
-                    request.id,
-                    task,
-                    (Task,),
-                    GetTaskSuccessResponse,
-                    GetTaskResponse,
-                )
-            raise ServerError(error=TaskNotFoundError())
-        except ServerError as e:
-            return GetTaskResponse(
-                root=JSONRPCErrorResponse(
-                    id=request.id, error=e.error if e.error else InternalError()
-                )
-            )
diff --git a/src/a2a/server/request_handlers/request_handler.py b/src/a2a/server/request_handlers/request_handler.py
index d7b37d76e..6fb42098f 100644
--- a/src/a2a/server/request_handlers/request_handler.py
+++ b/src/a2a/server/request_handlers/request_handler.py
@@ -1,58 +1,412 @@
+import functools
+import inspect
+import logging
+
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
+from typing import Any
+
+from google.protobuf.message import Message as ProtoMessage
 
+from a2a.server.context import ServerCallContext
 from a2a.server.events.event_queue import Event
-from a2a.types import (
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
     Message,
-    MessageSendParams,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
     Task,
-    TaskIdParams,
     TaskPushNotificationConfig,
-    TaskQueryParams,
-    UnsupportedOperationError,
 )
-from a2a.utils.errors import ServerError
+from a2a.utils.errors import UnsupportedOperationError
+from a2a.utils.proto_utils import validate_proto_required_fields
 
 
 class RequestHandler(ABC):
-    """A2A request handler interface."""
+    """A2A request handler interface.
+
+    This interface defines the methods that an A2A server implementation must
+    provide to handle incoming A2A requests from any transport (gRPC, REST, JSON-RPC).
+    """
 
     @abstractmethod
-    async def on_get_task(self, params: TaskQueryParams) -> Task | None:
-        pass
+    async def on_get_task(
+        self,
+        params: GetTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
+        """Handles the 'tasks/get' method.
+
+        Retrieves the state and history of a specific task.
+
+        Args:
+            params: Parameters specifying the task ID and optionally history length.
+            context: Context provided by the server.
+
+        Returns:
+            The `Task` object if found, otherwise `None`.
+        """
 
     @abstractmethod
-    async def on_cancel_task(self, params: TaskIdParams) -> Task | None:
-        pass
+    async def on_list_tasks(
+        self, params: ListTasksRequest, context: ServerCallContext
+    ) -> ListTasksResponse:
+        """Handles the tasks/list method.
+
+        Retrieves all tasks for an agent. Supports filtering, pagination,
+        ordering, limiting the history length, excluding artifacts, etc.
+
+        Args:
+            params: Parameters with filtering criteria.
+            context: Context provided by the server.
+
+        Returns:
+            The `ListTasksResponse` containing the tasks.
+        """
+
+    @abstractmethod
+    async def on_cancel_task(
+        self,
+        params: CancelTaskRequest,
+        context: ServerCallContext,
+    ) -> Task | None:
+        """Handles the 'tasks/cancel' method.
+
+        Requests the agent to cancel an ongoing task.
+
+        Args:
+            params: Parameters specifying the task ID.
+            context: Context provided by the server.
+
+        Returns:
+            The `Task` object with its status updated to canceled, or `None` if the task was not found.
+        """
 
     @abstractmethod
     async def on_message_send(
-        self, params: MessageSendParams
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
     ) -> Task | Message:
-        pass
+        """Handles the 'message/send' method (non-streaming).
+
+        Sends a message to the agent to create, continue, or restart a task,
+        and waits for the final result (Task or Message).
+
+        Args:
+            params: Parameters including the message and configuration.
+            context: Context provided by the server.
+
+        Returns:
+            The final `Task` object or a final `Message` object.
+        """
 
     @abstractmethod
     async def on_message_send_stream(
-        self, params: MessageSendParams
-    ) -> AsyncGenerator[Event, None]:
-        raise ServerError(error=UnsupportedOperationError())
+        self,
+        params: SendMessageRequest,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event]:
+        """Handles the 'message/stream' method (streaming).
+
+        Sends a message to the agent and yields stream events as they are
+        produced (Task updates, Message chunks, Artifact updates).
+
+        Args:
+            params: Parameters including the message and configuration.
+            context: Context provided by the server.
+
+        Yields:
+            `Event` objects from the agent's execution.
+        """
+        # This is needed for typechecker to recognise this method as an async generator.
+        raise UnsupportedOperationError
         yield
 
     @abstractmethod
-    async def on_set_task_push_notification_config(
-        self, params: TaskPushNotificationConfig
+    async def on_create_task_push_notification_config(
+        self,
+        params: TaskPushNotificationConfig,
+        context: ServerCallContext,
     ) -> TaskPushNotificationConfig:
-        pass
+        """Handles the 'tasks/pushNotificationConfig/create' method.
+
+        Sets or updates the push notification configuration for a task.
+
+        Args:
+            params: Parameters including the task ID and push notification configuration.
+            context: Context provided by the server.
+
+        Returns:
+            The provided `TaskPushNotificationConfig` upon success.
+        """
 
     @abstractmethod
     async def on_get_task_push_notification_config(
-        self, params: TaskIdParams
+        self,
+        params: GetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
     ) -> TaskPushNotificationConfig:
-        pass
+        """Handles the 'tasks/pushNotificationConfig/get' method.
+
+        Retrieves the current push notification configuration for a task.
+
+        Args:
+            params: Parameters including the task ID.
+            context: Context provided by the server.
+
+        Returns:
+            The `TaskPushNotificationConfig` for the task.
+        """
 
     @abstractmethod
-    async def on_resubscribe_to_task(
-        self, params: TaskIdParams
-    ) -> AsyncGenerator[Event, None]:
-        raise ServerError(error=UnsupportedOperationError())
+    async def on_subscribe_to_task(
+        self,
+        params: SubscribeToTaskRequest,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[Event]:
+        """Handles the 'SubscribeToTask' method.
+
+        Allows a client to subscribe to a running streaming task's event stream.
+
+        Args:
+            params: Parameters including the task ID.
+            context: Context provided by the server.
+
+        Yields:
+             `Event` objects from the agent's ongoing execution for the specified task.
+        """
+        raise UnsupportedOperationError
         yield
+
+    @abstractmethod
+    async def on_list_task_push_notification_configs(
+        self,
+        params: ListTaskPushNotificationConfigsRequest,
+        context: ServerCallContext,
+    ) -> ListTaskPushNotificationConfigsResponse:
+        """Handles the 'ListTaskPushNotificationConfigs' method.
+
+        Retrieves the current push notification configurations for a task.
+
+        Args:
+            params: Parameters including the task ID.
+            context: Context provided by the server.
+
+        Returns:
+            The `list[TaskPushNotificationConfig]` for the task.
+        """
+
+    @abstractmethod
+    async def on_delete_task_push_notification_config(
+        self,
+        params: DeleteTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> None:
+        """Handles the 'tasks/pushNotificationConfig/delete' method.
+
+        Deletes a push notification configuration associated with a task.
+
+        Args:
+            params: Parameters including the task ID.
+            context: Context provided by the server.
+
+        Returns:
+            None
+        """
+
+    @abstractmethod
+    async def on_get_extended_agent_card(
+        self,
+        params: GetExtendedAgentCardRequest,
+        context: ServerCallContext,
+    ) -> AgentCard:
+        """Handles the 'GetExtendedAgentCard' method.
+
+        Retrieves the extended agent card for the agent.
+
+        Args:
+            params: Parameters for the request.
+            context: Context provided by the server.
+
+        Returns:
+            The `AgentCard` object representing the extended properties of the agent.
+
+        """
+
+
+def validate_request_params(method: Callable) -> Callable:
+    """Decorator for RequestHandler methods to validate required fields on incoming requests."""
+    if inspect.isasyncgenfunction(method):
+
+        @functools.wraps(method)
+        async def async_gen_wrapper(
+            self: RequestHandler,
+            params: ProtoMessage,
+            context: ServerCallContext,
+            *args: Any,
+            **kwargs: Any,
+        ) -> Any:
+            if params is not None:
+                validate_proto_required_fields(params)
+            # Ensure the inner async generator is closed explicitly;
+            # bare async-for does not call aclose() on GeneratorExit,
+            # which on Python 3.12+ prevents the except/finally blocks
+            # in on_message_send_stream from running on client disconnect
+            # (background_consume and cleanup_producer tasks are never created).
+            inner = method(self, params, context, *args, **kwargs)
+            try:
+                async for item in inner:
+                    yield item
+            finally:
+                await inner.aclose()
+
+        return async_gen_wrapper
+
+    @functools.wraps(method)
+    async def async_wrapper(
+        self: RequestHandler,
+        params: ProtoMessage,
+        context: ServerCallContext,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        if params is not None:
+            validate_proto_required_fields(params)
+        return await method(self, params, context, *args, **kwargs)
+
+    return async_wrapper
+
+
+def validate(
+    expression: Callable[[Any], bool],
+    error_message: str | None = None,
+    error_type: type[Exception] = UnsupportedOperationError,
+) -> Callable:
+    """Decorator that validates if a given expression evaluates to True.
+
+    Typically used on class methods to check capabilities or configuration
+    before executing the method's logic. If the expression is False,
+    the specified `error_type` (defaults to `UnsupportedOperationError`) is raised.
+
+    Args:
+        expression: A callable that takes the instance (`self`) as its argument
+                    and returns a boolean.
+        error_message: An optional custom error message for the error raised.
+                       If None, the string representation of the expression will be used.
+        error_type: The exception class to raise on validation failure.
+                   Must take a `message` keyword argument (inherited from A2AError).
+
+    Examples:
+        Demonstrating with an async method:
+        >>> import asyncio
+        >>> from a2a.utils.errors import UnsupportedOperationError
+        >>>
+        >>> class MyAgent:
+        ...     def __init__(self, streaming_enabled: bool):
+        ...         self.streaming_enabled = streaming_enabled
+        ...
+        ...     @validate(
+        ...         lambda self: self.streaming_enabled,
+        ...         'Streaming is not enabled for this agent',
+        ...     )
+        ...     async def stream_response(self, message: str):
+        ...         return f'Streaming: {message}'
+        >>>
+        >>> async def run_async_test():
+        ...     # Successful call
+        ...     agent_ok = MyAgent(streaming_enabled=True)
+        ...     result = await agent_ok.stream_response('hello')
+        ...     print(result)
+        ...
+        ...     # Call that fails validation
+        ...     agent_fail = MyAgent(streaming_enabled=False)
+        ...     try:
+        ...         await agent_fail.stream_response('world')
+        ...     except UnsupportedOperationError as e:
+        ...         print(e.message)
+        >>>
+        >>> asyncio.run(run_async_test())
+        Streaming: hello
+        Streaming is not enabled for this agent
+
+        Demonstrating with a sync method:
+        >>> class SecureAgent:
+        ...     def __init__(self):
+        ...         self.auth_enabled = False
+        ...
+        ...     @validate(
+        ...         lambda self: self.auth_enabled,
+        ...         'Authentication must be enabled for this operation',
+        ...     )
+        ...     def secure_operation(self, data: str):
+        ...         return f'Processing secure data: {data}'
+        >>>
+        >>> # Error case example
+        >>> agent = SecureAgent()
+        >>> try:
+        ...     agent.secure_operation('secret')
+        ... except UnsupportedOperationError as e:
+        ...     print(e.message)
+        Authentication must be enabled for this operation
+
+    Note:
+        This decorator works with both sync and async methods automatically.
+    """
+
+    def decorator(function: Callable) -> Callable:
+        if inspect.isasyncgenfunction(function):
+
+            @functools.wraps(function)
+            async def async_gen_wrapper(self: Any, *args, **kwargs) -> Any:
+                if not expression(self):
+                    final_message = error_message or str(expression)
+                    logging.getLogger(__name__).error(
+                        'Validation failure: %s', final_message
+                    )
+                    raise error_type(final_message)
+                inner = function(self, *args, **kwargs)
+                try:
+                    async for item in inner:
+                        yield item
+                finally:
+                    await inner.aclose()
+
+            return async_gen_wrapper
+
+        if inspect.iscoroutinefunction(function):
+
+            @functools.wraps(function)
+            async def async_wrapper(self: Any, *args, **kwargs) -> Any:
+                if not expression(self):
+                    final_message = error_message or str(expression)
+                    logging.getLogger(__name__).error(
+                        'Validation failure: %s', final_message
+                    )
+                    raise error_type(final_message)
+                return await function(self, *args, **kwargs)
+
+            return async_wrapper
+
+        @functools.wraps(function)
+        def sync_wrapper(self: Any, *args, **kwargs) -> Any:
+            if not expression(self):
+                final_message = error_message or str(expression)
+                logging.getLogger(__name__).error(
+                    'Validation failure: %s', final_message
+                )
+                raise error_type(final_message)
+            return function(self, *args, **kwargs)
+
+        return sync_wrapper
+
+    return decorator
diff --git a/src/a2a/server/request_handlers/response_helpers.py b/src/a2a/server/request_handlers/response_helpers.py
index 3af1c2eb8..262e1030b 100644
--- a/src/a2a/server/request_handlers/response_helpers.py
+++ b/src/a2a/server/request_handlers/response_helpers.py
@@ -1,100 +1,185 @@
-# response types
-from typing import TypeVar
+"""Helper functions for building A2A JSON-RPC responses."""
 
-from a2a.types import (
-    A2AError,
-    CancelTaskResponse,
-    CancelTaskSuccessResponse,
-    GetTaskPushNotificationConfigResponse,
-    GetTaskPushNotificationConfigSuccessResponse,
-    GetTaskResponse,
-    GetTaskSuccessResponse,
-    InvalidAgentResponseError,
+from typing import Any
+
+from google.protobuf.json_format import MessageToDict
+from google.protobuf.message import Message as ProtoMessage
+from jsonrpc.jsonrpc2 import JSONRPC20Response
+
+from a2a.compat.v0_3.conversions import to_compat_agent_card
+from a2a.server.jsonrpc_models import (
+    InternalError as JSONRPCInternalError,
+)
+from a2a.server.jsonrpc_models import (
     JSONRPCError,
-    JSONRPCErrorResponse,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    ListTasksResponse,
     Message,
-    SendMessageResponse,
-    SendMessageSuccessResponse,
-    SendStreamingMessageResponse,
-    SendStreamingMessageSuccessResponse,
-    SetTaskPushNotificationConfigResponse,
-    SetTaskPushNotificationConfigSuccessResponse,
+    StreamResponse,
     Task,
     TaskArtifactUpdateEvent,
     TaskPushNotificationConfig,
     TaskStatusUpdateEvent,
 )
+from a2a.types.a2a_pb2 import (
+    SendMessageResponse as SendMessageResponseProto,
+)
+from a2a.utils.error_handlers import build_error_details
+from a2a.utils.errors import (
+    JSON_RPC_ERROR_CODE_MAP,
+    A2AError,
+    ContentTypeNotSupportedError,
+    ExtendedAgentCardNotConfiguredError,
+    ExtensionSupportRequiredError,
+    InternalError,
+    InvalidAgentResponseError,
+    InvalidParamsError,
+    InvalidRequestError,
+    MethodNotFoundError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+    VersionNotSupportedError,
+)
+from a2a.utils.proto_utils import warn_on_missing_required_fields
 
 
-RT = TypeVar(
-    'RT',
-    GetTaskResponse,
-    CancelTaskResponse,
-    SendMessageResponse,
-    SetTaskPushNotificationConfigResponse,
-    GetTaskPushNotificationConfigResponse,
-    SendStreamingMessageResponse,
-)
+EXCEPTION_MAP: dict[type[A2AError], type[JSONRPCError]] = {
+    TaskNotFoundError: JSONRPCError,
+    TaskNotCancelableError: JSONRPCError,
+    PushNotificationNotSupportedError: JSONRPCError,
+    UnsupportedOperationError: JSONRPCError,
+    ContentTypeNotSupportedError: JSONRPCError,
+    InvalidAgentResponseError: JSONRPCError,
+    ExtendedAgentCardNotConfiguredError: JSONRPCError,
+    InvalidParamsError: JSONRPCError,
+    InvalidRequestError: JSONRPCError,
+    MethodNotFoundError: JSONRPCError,
+    InternalError: JSONRPCInternalError,
+    ExtensionSupportRequiredError: JSONRPCError,
+    VersionNotSupportedError: JSONRPCError,
+}
 
-# success types
-SPT = TypeVar(
-    'SPT',
-    GetTaskSuccessResponse,
-    CancelTaskSuccessResponse,
-    SendMessageSuccessResponse,
-    SetTaskPushNotificationConfigSuccessResponse,
-    GetTaskPushNotificationConfigSuccessResponse,
-    SendStreamingMessageSuccessResponse,
-)
 
-# result types
+# Tuple of all A2AError types for isinstance checks
+_A2A_ERROR_TYPES: tuple[type, ...] = (A2AError,)
+
+
+# Result types for handler responses
 EventTypes = (
     Task
     | Message
     | TaskArtifactUpdateEvent
     | TaskStatusUpdateEvent
     | TaskPushNotificationConfig
+    | StreamResponse
+    | SendMessageResponseProto
     | A2AError
     | JSONRPCError
+    | list[TaskPushNotificationConfig]
+    | ListTasksResponse
 )
+"""Type alias for possible event types produced by handlers."""
+
+
+def agent_card_to_dict(card: AgentCard) -> dict[str, Any]:
+    """Convert AgentCard to dict and inject backward compatibility fields."""
+    warn_on_missing_required_fields(
+        card, 'agent_card passed to agent_card_to_dict:'
+    )
+    result = MessageToDict(card)
+
+    try:
+        compat_card = to_compat_agent_card(card)
+        compat_dict = compat_card.model_dump(exclude_none=True)
+    except VersionNotSupportedError:
+        compat_dict = {}
+
+    # Do not include supportsAuthenticatedExtendedCard if false
+    if not compat_dict.get('supportsAuthenticatedExtendedCard'):
+        compat_dict.pop('supportsAuthenticatedExtendedCard', None)
+
+    def merge(dict1: dict[str, Any], dict2: dict[str, Any]) -> dict[str, Any]:
+        for k, v in dict2.items():
+            if k not in dict1:
+                dict1[k] = v
+            elif isinstance(v, dict) and isinstance(dict1[k], dict):
+                merge(dict1[k], v)
+            elif isinstance(v, list) and isinstance(dict1[k], list):
+                for i in range(min(len(dict1[k]), len(v))):
+                    if isinstance(dict1[k][i], dict) and isinstance(v[i], dict):
+                        merge(dict1[k][i], v[i])
+        return dict1
+
+    return merge(result, compat_dict)
 
 
 def build_error_response(
     request_id: str | int | None,
     error: A2AError | JSONRPCError,
-    response_wrapper_type: type[RT],
-) -> RT:
-    """Helper method to build a JSONRPCErrorResponse."""
-    return response_wrapper_type(
-        JSONRPCErrorResponse(
-            id=request_id,
-            error=error.root if isinstance(error, A2AError) else error,
+) -> dict[str, Any]:
+    """Build a JSON-RPC error response dict.
+
+    Args:
+        request_id: The ID of the request that caused the error.
+        error: The A2AError or JSONRPCError object.
+
+    Returns:
+        A dict representing the JSON-RPC error response.
+    """
+    jsonrpc_error: JSONRPCError
+    if isinstance(error, JSONRPCError):
+        jsonrpc_error = error
+    elif isinstance(error, A2AError):
+        error_type = type(error)
+        model_class = EXCEPTION_MAP.get(error_type, JSONRPCInternalError)
+        code = JSON_RPC_ERROR_CODE_MAP.get(error_type, -32603)
+        jsonrpc_error = model_class(
+            code=code,
+            message=str(error),
+            data=build_error_details(error),
         )
-    )
+    else:
+        jsonrpc_error = JSONRPCInternalError(message=str(error))
+
+    error_dict = jsonrpc_error.model_dump(exclude_none=True)
+    return JSONRPC20Response(error=error_dict, _id=request_id).data
 
 
 def prepare_response_object(
     request_id: str | int | None,
     response: EventTypes,
     success_response_types: tuple[type, ...],
-    success_payload_type: type[SPT],
-    response_type: type[RT],
-) -> RT:
-    """Helper method to build appropriate JSONRPCResponse object for RPC methods."""
+) -> dict[str, Any]:
+    """Build a JSON-RPC response dict from handler output.
+
+    Based on the type of the `response` object received from the handler,
+    it constructs either a success response or an error response.
+
+    Args:
+        request_id: The ID of the request.
+        response: The object received from the request handler.
+        success_response_types: A tuple of expected types for a successful result.
+
+    Returns:
+        A dict representing the JSON-RPC response (success or error).
+    """
     if isinstance(response, success_response_types):
-        return response_type(
-            root=success_payload_type(id=request_id, result=response)  # type:ignore
-        )
+        # Convert proto message to dict for JSON serialization
+        result: Any = response
+        if isinstance(response, ProtoMessage):
+            result = MessageToDict(response, preserving_proto_field_name=False)
+        return JSONRPC20Response(result=result, _id=request_id).data
 
     if isinstance(response, A2AError | JSONRPCError):
-        return build_error_response(request_id, response, response_type)
+        return build_error_response(request_id, response)
 
-    # If consumer_data is not an expected success type and not an error,
-    # it's an invalid type of response from the agent for this specific method.
-    response = A2AError(
-        root=InvalidAgentResponseError(
-            message='Agent returned invalid type response for this method'
-        )
+    # If response is not an expected success type and not an error,
+    # it's an invalid type of response from the agent for this method.
+    error = InvalidAgentResponseError(
+        message='Agent returned invalid type response for this method'
     )
-
-    return build_error_response(request_id, response, response_type)
+    return build_error_response(request_id, error)
diff --git a/src/a2a/server/routes/__init__.py b/src/a2a/server/routes/__init__.py
new file mode 100644
index 000000000..749774dc7
--- /dev/null
+++ b/src/a2a/server/routes/__init__.py
@@ -0,0 +1,20 @@
+"""A2A Routes."""
+
+from a2a.server.routes.agent_card_routes import create_agent_card_routes
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    ServerCallContextBuilder,
+)
+from a2a.server.routes.fastapi_routes import add_a2a_routes_to_fastapi
+from a2a.server.routes.jsonrpc_routes import create_jsonrpc_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+
+
+__all__ = [
+    'DefaultServerCallContextBuilder',
+    'ServerCallContextBuilder',
+    'add_a2a_routes_to_fastapi',
+    'create_agent_card_routes',
+    'create_jsonrpc_routes',
+    'create_rest_routes',
+]
diff --git a/src/a2a/server/routes/_jsonrpc_schema.py b/src/a2a/server/routes/_jsonrpc_schema.py
new file mode 100644
index 000000000..9a3264b3c
--- /dev/null
+++ b/src/a2a/server/routes/_jsonrpc_schema.py
@@ -0,0 +1,82 @@
+"""JSON-RPC envelope schema utilities for A2A server routes."""
+
+from typing import Any
+
+from google.protobuf.message import Message
+
+from a2a.server.routes._proto_schema import message_schema
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    TaskPushNotificationConfig,
+)
+
+
+METHOD_TYPES: dict[str, type[Message]] = {
+    'SendMessage': SendMessageRequest,
+    'SendStreamingMessage': SendMessageRequest,
+    'GetTask': GetTaskRequest,
+    'ListTasks': ListTasksRequest,
+    'CancelTask': CancelTaskRequest,
+    'CreateTaskPushNotificationConfig': TaskPushNotificationConfig,
+    'GetTaskPushNotificationConfig': GetTaskPushNotificationConfigRequest,
+    'ListTaskPushNotificationConfigs': ListTaskPushNotificationConfigsRequest,
+    'DeleteTaskPushNotificationConfig': DeleteTaskPushNotificationConfigRequest,
+    'SubscribeToTask': SubscribeToTaskRequest,
+    'GetExtendedAgentCard': GetExtendedAgentCardRequest,
+}
+
+DESCRIPTION = """\
+A2A JSON-RPC 2.0 endpoint. The `method` field selects the operation;
+`params` must match that method's schema (see the `oneOf` below).
+
+**Supported methods:**
+
+- `SendMessage` — Send a message to the agent (returns a Task or response Message).
+- `SendStreamingMessage` — Send a message and receive a Server-Sent Events stream.
+- `GetTask` — Fetch a task by ID.
+- `ListTasks` — List tasks with pagination and filtering.
+- `CancelTask` — Cancel an in-progress task.
+- `CreateTaskPushNotificationConfig` — Register a push-notification config on a task.
+- `GetTaskPushNotificationConfig` — Read a single push-notification config.
+- `ListTaskPushNotificationConfigs` — List all push-notification configs for a task.
+- `DeleteTaskPushNotificationConfig` — Delete a push-notification config.
+- `SubscribeToTask` — Subscribe to task events via Server-Sent Events.
+- `GetExtendedAgentCard` — Fetch the authenticated extended agent card.
+"""
+
+
+def envelope_schema(components: dict[str, Any]) -> dict[str, Any]:
+    """Builds the A2ARequest JSON-RPC envelope schema with a oneOf over all method params."""
+    params_refs = [
+        message_schema(cls.DESCRIPTOR, components)
+        for cls in dict.fromkeys(METHOD_TYPES.values())
+    ]
+
+    components['A2ARequest'] = {
+        'type': 'object',
+        'required': ['jsonrpc', 'method'],
+        'properties': {
+            'jsonrpc': {'type': 'string', 'enum': ['2.0']},
+            'id': {
+                'oneOf': [
+                    {'type': 'string'},
+                    {'type': 'integer'},
+                    {'type': 'null'},
+                ],
+            },
+            'method': {
+                'type': 'string',
+                'enum': list(METHOD_TYPES),
+            },
+            'params': {'oneOf': params_refs},
+        },
+    }
+    return {'$ref': '#/components/schemas/A2ARequest'}
diff --git a/src/a2a/server/routes/_proto_schema.py b/src/a2a/server/routes/_proto_schema.py
new file mode 100644
index 000000000..1f066a151
--- /dev/null
+++ b/src/a2a/server/routes/_proto_schema.py
@@ -0,0 +1,187 @@
+"""Proto → JSON Schema utilities for A2A server routes."""
+
+from typing import Any
+
+from google.api import field_behavior_pb2 as fb
+from google.protobuf.descriptor import Descriptor, FieldDescriptor
+from google.protobuf.message import Message
+
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    SendMessageRequest,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.proto_utils import _field_is_repeated
+
+
+REST_BODY_TYPES: dict[tuple[str, str], type[Message]] = {
+    ('/message:send', 'POST'): SendMessageRequest,
+    ('/message:stream', 'POST'): SendMessageRequest,
+    ('/tasks/{id}:cancel', 'POST'): CancelTaskRequest,
+    ('/tasks/{id}/pushNotificationConfigs', 'POST'): TaskPushNotificationConfig,
+}
+
+# 64-bit integer types serialize as strings in protojson.
+_PROTO_SCALAR_SCHEMAS: dict[int, dict[str, Any]] = {
+    FieldDescriptor.TYPE_DOUBLE: {'type': 'number'},
+    FieldDescriptor.TYPE_FLOAT: {'type': 'number'},
+    FieldDescriptor.TYPE_INT64: {'type': 'string', 'format': 'int64'},
+    FieldDescriptor.TYPE_UINT64: {'type': 'string', 'format': 'uint64'},
+    FieldDescriptor.TYPE_INT32: {'type': 'integer', 'format': 'int32'},
+    FieldDescriptor.TYPE_FIXED64: {'type': 'string', 'format': 'fixed64'},
+    FieldDescriptor.TYPE_FIXED32: {'type': 'integer', 'format': 'fixed32'},
+    FieldDescriptor.TYPE_BOOL: {'type': 'boolean'},
+    FieldDescriptor.TYPE_STRING: {'type': 'string'},
+    FieldDescriptor.TYPE_BYTES: {'type': 'string', 'format': 'byte'},
+    FieldDescriptor.TYPE_UINT32: {'type': 'integer', 'format': 'uint32'},
+    FieldDescriptor.TYPE_SFIXED32: {'type': 'integer'},
+    FieldDescriptor.TYPE_SFIXED64: {'type': 'string'},
+    FieldDescriptor.TYPE_SINT32: {'type': 'integer'},
+    FieldDescriptor.TYPE_SINT64: {'type': 'string'},
+}
+
+
+def _is_required(field: FieldDescriptor) -> bool:
+    """Returns True if the field carries google.api.field_behavior = REQUIRED."""
+    return fb.REQUIRED in field.GetOptions().Extensions[fb.field_behavior]  # type: ignore[index]  # ty: ignore[invalid-argument-type]
+
+
+_WELL_KNOWN_SCHEMAS: dict[str, dict[str, Any]] = {
+    'google.protobuf.Timestamp': {'type': 'string', 'format': 'date-time'},
+    'google.protobuf.Duration': {'type': 'string'},
+    'google.protobuf.Struct': {'type': 'object'},
+    'google.protobuf.Value': {},
+    'google.protobuf.ListValue': {'type': 'array', 'items': {}},
+    'google.protobuf.Empty': {'type': 'object'},
+    'google.protobuf.Any': {'type': 'object'},
+    'google.protobuf.FieldMask': {'type': 'string'},
+}
+
+
+def field_schema(
+    field: FieldDescriptor, components: dict[str, Any]
+) -> dict[str, Any]:
+    if field.message_type and field.message_type.GetOptions().map_entry:
+        value_field = field.message_type.fields_by_name['value']
+        return {
+            'type': 'object',
+            'additionalProperties': field_schema(value_field, components),
+        }
+
+    if field.type == FieldDescriptor.TYPE_MESSAGE:
+        item = message_schema(field.message_type, components)
+        # Well-known types return an inline schema (no $ref); don't wrap them as
+        # nullable — they're already inlined as their JSON-Schema equivalent.
+        # Repeated fields must not return early here — they fall through to the
+        # array-wrapping block below.
+        if (
+            not _field_is_repeated(field)
+            and not _is_required(field)
+            and '$ref' in item
+        ):
+            return {'oneOf': [item, {'type': 'null'}], 'example': None}
+    elif field.type == FieldDescriptor.TYPE_ENUM and field.enum_type:
+        values = [v.name for v in field.enum_type.values]
+        example = next(
+            (
+                v
+                for v in values
+                if 'UNSPECIFIED' not in v and 'UNKNOWN' not in v
+            ),
+            values[0] if values else None,
+        )
+        item: dict[str, Any] = {'type': 'string', 'enum': values}
+        if example:
+            item['example'] = example
+    else:
+        item = dict(_PROTO_SCALAR_SCHEMAS.get(field.type, {'type': 'string'}))
+        if field.type == FieldDescriptor.TYPE_STRING:
+            # REQUIRED fields must be non-empty; use the field name as a
+            # recognisable placeholder. All other strings default to "".
+            item['example'] = field.name if _is_required(field) else ''
+        elif field.type == FieldDescriptor.TYPE_BOOL:
+            item['example'] = False
+
+    if _field_is_repeated(field):
+        array_schema: dict[str, Any] = {'type': 'array', 'items': item}
+        # Propagate the item example to the array so Swagger pre-fills one entry
+        # instead of generating one entry per oneOf branch.
+        item_example = (
+            components.get(item['$ref'].split('/')[-1], {}).get('example')
+            if '$ref' in item
+            else item.get('example')
+        )
+        if item_example is not None:
+            array_schema['example'] = [item_example]
+        return array_schema
+    return item
+
+
+def message_schema(
+    descriptor: Descriptor | Any, components: dict[str, Any]
+) -> dict[str, Any]:
+    """Returns a $ref to descriptor's schema, registering it in components if needed."""
+    if descriptor.full_name in _WELL_KNOWN_SCHEMAS:
+        return dict(_WELL_KNOWN_SCHEMAS[descriptor.full_name])
+
+    name = descriptor.name
+    ref = {'$ref': f'#/components/schemas/{name}'}
+    if name in components:
+        return ref
+
+    # Reserve the slot before recursing so cyclic types terminate.
+    components[name] = {}
+
+    real_oneofs = [o for o in descriptor.oneofs if len(o.fields) > 1]
+    oneof_field_names = {f.name for o in real_oneofs for f in o.fields}
+    base_properties = {
+        f.name: field_schema(f, components)
+        for f in descriptor.fields
+        if f.name not in oneof_field_names
+    }
+
+    if not real_oneofs:
+        components[name] = {'type': 'object', 'properties': base_properties}
+        return ref
+
+    oneof_constraints = [
+        {
+            'oneOf': [
+                {
+                    'type': 'object',
+                    'properties': {f.name: field_schema(f, components)},
+                    'required': [f.name],
+                }
+                for f in oneof.fields
+            ]
+        }
+        for oneof in real_oneofs
+    ]
+    parts: list[dict[str, Any]] = []
+    if base_properties:
+        parts.append({'type': 'object', 'properties': base_properties})
+    parts.extend(oneof_constraints)
+    schema: dict[str, Any] = parts[0] if len(parts) == 1 else {'allOf': parts}
+    # Provide a single concrete example using the first oneof variant so Swagger
+    # doesn't expand every branch into separate array items.
+    first_oneof_field = real_oneofs[0].fields[0]
+    first_field_schema = field_schema(first_oneof_field, components)
+    if 'example' in first_field_schema:
+        first_example: Any = first_field_schema['example']
+    elif '$ref' in first_field_schema:
+        ref_name = first_field_schema['$ref'].split('/')[-1]
+        first_example = components.get(ref_name, {}).get('example')
+    else:
+        _type_defaults: dict[str, Any] = {
+            'integer': 0,
+            'number': 0.0,
+            'boolean': False,
+            'array': [],
+            'object': {},
+        }
+        first_example = _type_defaults.get(
+            first_field_schema.get('type', 'string'), ''
+        )
+    schema['example'] = {first_oneof_field.name: first_example}
+    components[name] = schema
+    return ref
diff --git a/src/a2a/server/routes/agent_card_routes.py b/src/a2a/server/routes/agent_card_routes.py
new file mode 100644
index 000000000..5cf779a3c
--- /dev/null
+++ b/src/a2a/server/routes/agent_card_routes.py
@@ -0,0 +1,129 @@
+import hashlib
+import json
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+    from starlette.responses import JSONResponse, Response
+    from starlette.routing import Route
+
+    _package_starlette_installed = True
+else:
+    try:
+        from starlette.requests import Request
+        from starlette.responses import JSONResponse, Response
+        from starlette.routing import Route
+
+        _package_starlette_installed = True
+    except ImportError:
+        Route = Any
+        Request = Any
+        Response = Any
+        JSONResponse = Any
+
+        _package_starlette_installed = False
+
+from a2a.server.request_handlers.response_helpers import agent_card_to_dict
+from a2a.types.a2a_pb2 import AgentCard
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from a2a.utils.proto_utils import warn_on_missing_required_fields
+
+
+def _etag_for(card_dict: dict[str, Any]) -> str:
+    """A weak ETag derived from the card being served.
+
+    Hashed rather than taken from `version`, because `card_modifier` can
+    return a different card per request without touching `version`.
+
+    `signatures` is excluded and the tag is weak, which is what makes
+    revalidation work for a card signed per request. The signature covers
+    the card with `signatures` stripped, so it carries no information the
+    rest of the card does not -- but with a randomized algorithm such as
+    ES256 it differs on every signing, and a strong tag over it would change
+    on every request and never once match. A weak tag claims only semantic
+    equivalence, which two signings of identical content have.
+
+    The cost is that a 304 leaves the client on the signature it already
+    holds. That signature stays valid, since it covers content that has not
+    changed.
+
+    `sort_keys` rather than RFC 8785 canonicalization: an ETag is opaque and
+    is only ever compared against one this server produced, so determinism
+    is the whole requirement, and JCS would add a depth limit and a failure
+    mode for no gain.
+    """
+    unsigned = {k: v for k, v in card_dict.items() if k != 'signatures'}
+    body = json.dumps(unsigned, sort_keys=True, separators=(',', ':'))
+    return f'W/"{hashlib.sha256(body.encode("utf-8")).hexdigest()}"'
+
+
+def _if_none_match_hits(header: str, etag: str) -> bool:
+    """Whether an If-None-Match header selects this entity (RFC 9110 8.2.2)."""
+    candidates = [candidate.strip() for candidate in header.split(',')]
+    if '*' in candidates:
+        return True
+    # If-None-Match uses the weak comparison function, so W/"x" and "x" are
+    # the same entity on both sides of the comparison.
+    return any(
+        candidate.removeprefix('W/') == etag.removeprefix('W/')
+        for candidate in candidates
+    )
+
+
+def create_agent_card_routes(
+    agent_card: AgentCard,
+    card_modifier: Callable[[AgentCard], Awaitable[AgentCard]] | None = None,
+    card_url: str = AGENT_CARD_WELL_KNOWN_PATH,
+    cache_control: str | None = None,
+) -> list['Route']:
+    """Creates the Starlette Route for the A2A protocol agent card endpoint.
+
+    Args:
+        agent_card: The `AgentCard` to serve.
+        card_modifier: Optional callback to adjust the card per request.
+        card_url: Path the card is served from.
+        cache_control: Value for the `Cache-Control` response header, e.g.
+          ``'public, max-age=3600'``. A `max-age` has to suit the agent's
+          expected update frequency, which only the deployment knows, so
+          there is no default. The `ETag` is sent either way, and
+          revalidating against it costs one 304.
+    """
+    if not _package_starlette_installed:
+        raise ImportError(
+            'The `starlette` package is required to use `create_agent_card_routes`. '
+            'It can be installed as part of `a2a-sdk` optional dependencies, `a2a-sdk[http-server]`.'
+        )
+
+    warn_on_missing_required_fields(
+        agent_card, 'agent_card passed to create_agent_card_routes:'
+    )
+
+    async def _get_agent_card(request: Request) -> Response:
+        """Returns the public AgentCard describing this agent's capabilities, supported transports, and skills."""
+        card_to_serve = agent_card
+        if card_modifier:
+            card_to_serve = await card_modifier(card_to_serve)
+
+        card_dict = agent_card_to_dict(card_to_serve)
+        headers = {'ETag': _etag_for(card_dict)}
+        if cache_control:
+            headers['Cache-Control'] = cache_control
+
+        if_none_match = request.headers.get('if-none-match')
+        if if_none_match and _if_none_match_hits(
+            if_none_match, headers['ETag']
+        ):
+            return Response(status_code=304, headers=headers)
+
+        return JSONResponse(card_dict, headers=headers)
+
+    return [
+        Route(
+            path=card_url,
+            endpoint=_get_agent_card,
+            methods=['GET'],
+        )
+    ]
diff --git a/src/a2a/server/routes/common.py b/src/a2a/server/routes/common.py
new file mode 100644
index 000000000..93dc034b9
--- /dev/null
+++ b/src/a2a/server/routes/common.py
@@ -0,0 +1,135 @@
+from abc import ABC, abstractmethod
+from inspect import signature
+from typing import TYPE_CHECKING, Any
+
+from google.protobuf.json_format import MessageToDict
+
+from a2a.types.a2a_pb2 import ListTasksResponse
+
+
+if TYPE_CHECKING:
+    from sse_starlette.sse import EventSourceResponse
+    from starlette.authentication import BaseUser
+    from starlette.requests import Request
+else:
+    try:
+        from sse_starlette.sse import EventSourceResponse
+        from starlette.authentication import BaseUser
+        from starlette.requests import Request
+    except ImportError:
+        EventSourceResponse = Any
+        Request = Any
+        BaseUser = Any
+
+from a2a.auth.user import UnauthenticatedUser, User
+from a2a.extensions.common import (
+    HTTP_EXTENSION_HEADER,
+    get_requested_extensions,
+)
+from a2a.server.context import ServerCallContext
+
+
+def serialize_list_tasks_response(
+    response: ListTasksResponse, include_artifacts: bool
+) -> dict[str, Any]:
+    """Serializes a ListTasks response according to artifact semantics."""
+    result = MessageToDict(
+        response,
+        preserving_proto_field_name=False,
+        always_print_fields_with_no_presence=True,
+    )
+    if not include_artifacts:
+        for task in result['tasks']:
+            task.pop('artifacts', None)
+    return result
+
+
+def create_event_source_response(
+    content: Any,
+    shutdown_grace_period: float = 0,
+) -> 'EventSourceResponse':
+    """Creates an SSE response, preserving support for older sse-starlette.
+
+    A non-zero grace period requires cooperative shutdown support from
+    sse-starlette, provided by the HTTP server optional dependencies.
+    """
+    if shutdown_grace_period < 0:
+        raise ValueError('shutdown_grace_period must be >= 0')
+    if shutdown_grace_period:
+        if (
+            'shutdown_grace_period'
+            not in signature(EventSourceResponse.__init__).parameters
+        ):
+            raise RuntimeError(
+                'Configuring shutdown_grace_period requires sse-starlette with '
+                'cooperative shutdown support. Upgrade the dependencies for '
+                'a2a-sdk[http-server].'
+            )
+        return EventSourceResponse(
+            content, shutdown_grace_period=shutdown_grace_period
+        )
+    return EventSourceResponse(content)
+
+
+class StarletteUser(User):
+    """Adapts a Starlette BaseUser to the A2A User interface."""
+
+    def __init__(self, user: BaseUser):
+        self._user = user
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Returns whether the current user is authenticated."""
+        return self._user.is_authenticated
+
+    @property
+    def user_name(self) -> str:
+        """Returns the user name of the current user."""
+        return self._user.display_name
+
+
+class ServerCallContextBuilder(ABC):
+    """A class for building ServerCallContexts using the Starlette Request."""
+
+    @abstractmethod
+    def build(self, request: Request) -> ServerCallContext:
+        """Builds a ServerCallContext from a Starlette Request."""
+
+
+class DefaultServerCallContextBuilder(ServerCallContextBuilder):
+    """A default implementation of ServerCallContextBuilder."""
+
+    def build(self, request: Request) -> ServerCallContext:
+        """Builds a ServerCallContext from a Starlette Request.
+
+        Args:
+            request: The incoming Starlette Request object.
+
+        Returns:
+            A ServerCallContext instance populated with user and state
+            information from the request.
+        """
+        state = {}
+        if 'auth' in request.scope:
+            state['auth'] = request.auth
+        state['headers'] = dict(request.headers)
+        return ServerCallContext(
+            user=self.build_user(request),
+            state=state,
+            requested_extensions=get_requested_extensions(
+                request.headers.getlist(HTTP_EXTENSION_HEADER)
+            ),
+        )
+
+    def build_user(self, request: Request) -> User:
+        """Builds a User from a Starlette Request.
+
+        Args:
+            request: The incoming Starlette Request object.
+
+        Returns:
+            A User instance populated with user information from the request.
+        """
+        if 'user' in request.scope:
+            return StarletteUser(request.user)
+        return UnauthenticatedUser()
diff --git a/src/a2a/server/routes/fastapi_routes.py b/src/a2a/server/routes/fastapi_routes.py
new file mode 100644
index 000000000..77c0c0711
--- /dev/null
+++ b/src/a2a/server/routes/fastapi_routes.py
@@ -0,0 +1,204 @@
+from typing import TYPE_CHECKING, Any
+
+from a2a.server.routes._jsonrpc_schema import (
+    DESCRIPTION as _JSONRPC_DESCRIPTION,
+)
+from a2a.server.routes._jsonrpc_schema import (
+    envelope_schema as _jsonrpc_envelope_schema,
+)
+from a2a.server.routes._proto_schema import (
+    REST_BODY_TYPES,
+    message_schema,
+)
+from a2a.utils.constants import PROTOCOL_VERSION_1_0, VERSION_HEADER
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from fastapi import FastAPI
+    from fastapi.routing import APIRoute as _A2ARoute
+    from starlette.routing import BaseRoute, Route
+
+    _package_fastapi_installed = True
+else:
+    try:
+        from fastapi.routing import APIRoute
+        from starlette.routing import Route, request_response
+
+        class _A2ARoute(APIRoute):
+            """APIRoute that uses Starlette's request_response to bypass FastAPI middleware scope requirements."""
+
+            def __init__(self, *args: Any, **kwargs: Any) -> None:
+                super().__init__(*args, **kwargs)
+                self.app = request_response(self.endpoint)
+
+        _package_fastapi_installed = True
+    except ImportError:
+        Route = Any
+        _A2ARoute = Any
+
+        _package_fastapi_installed = False
+
+
+_AGENT_CARD_TAG = 'A2A: Agent Card'
+_JSONRPC_TAG = 'A2A: JSON-RPC'
+_REST_TAG = 'A2A: REST'
+
+_A2A_VERSION_HEADER = {
+    'in': 'header',
+    'name': VERSION_HEADER,
+    'required': True,
+    'schema': {'type': 'string', 'enum': [PROTOCOL_VERSION_1_0]},
+    'example': PROTOCOL_VERSION_1_0,
+}
+
+
+_OPTIONAL_REST_BODIES: frozenset[tuple[str, str]] = frozenset(
+    {('/tasks/{id}:cancel', 'POST')}
+)
+
+
+def _request_body_extra(
+    ref: dict[str, Any], description: str, *, required: bool = True
+) -> dict[str, Any]:
+    return {
+        'requestBody': {
+            'description': description,
+            'required': required,
+            'content': {'application/json': {'schema': ref}},
+        },
+    }
+
+
+def _rest_body_extra(
+    route: 'Route', rest_bodies: dict[tuple[str, str], dict[str, Any]]
+) -> dict[str, Any] | None:
+    methods = route.methods or set()
+    for (suffix, method), extra in rest_bodies.items():
+        if method in methods and route.path.endswith(suffix):
+            return extra
+    return None
+
+
+def _attach_route(
+    app: 'FastAPI',
+    route: 'BaseRoute',
+    tag: str,
+    openapi_extra: dict[str, Any] | None,
+    require_version_header: bool = False,
+) -> None:
+    if not (isinstance(route, Route) and route.methods):
+        app.routes.append(route)
+        return
+    # Drop HEAD: Starlette adds it alongside GET, but FastAPI registers duplicate operation IDs.
+    methods = sorted(m for m in route.methods if m != 'HEAD')
+    if require_version_header:
+        extra = dict(openapi_extra or {})
+        extra.setdefault('parameters', [_A2A_VERSION_HEADER])
+        openapi_extra = extra
+    app.routes.append(
+        _A2ARoute(
+            path=route.path,
+            endpoint=route.endpoint,
+            methods=methods,
+            tags=[tag],
+            openapi_extra=openapi_extra,
+        )
+    )
+
+
+def add_a2a_routes_to_fastapi(
+    app: 'FastAPI',
+    *,
+    agent_card_routes: 'Sequence[BaseRoute] | None' = None,
+    jsonrpc_routes: 'Sequence[BaseRoute] | None' = None,
+    rest_routes: 'Sequence[BaseRoute] | None' = None,
+) -> None:
+    """Mounts A2A routes on a FastAPI app and enriches them for ``/docs``.
+
+    Re-registers Starlette routes as ``APIRoute`` instances so they appear in
+    the auto-generated OpenAPI schema, tagged and annotated with proto-derived
+    request-body schemas.
+
+    Usage::
+
+        app = FastAPI()
+        add_a2a_routes_to_fastapi(
+            app,
+            agent_card_routes=create_agent_card_routes(agent_card),
+            jsonrpc_routes=create_jsonrpc_routes(request_handler, rpc_url='/'),
+            rest_routes=create_rest_routes(request_handler),
+        )
+
+    Args:
+        app: The FastAPI application to mount the routes on.
+        agent_card_routes: Routes returned by ``create_agent_card_routes``.
+        jsonrpc_routes: Routes returned by ``create_jsonrpc_routes``.
+        rest_routes: Routes returned by ``create_rest_routes``.
+    """
+    if not _package_fastapi_installed:
+        raise ImportError(
+            'The `fastapi` package is required to use '
+            '`add_a2a_routes_to_fastapi`. Install it via '
+            '`a2a-sdk[fastapi]`.'
+        )
+
+    components: dict[str, Any] = {}
+    jsonrpc_extra = {
+        'summary': 'A2A JSON-RPC endpoint',
+        'description': _JSONRPC_DESCRIPTION,
+        **_request_body_extra(
+            _jsonrpc_envelope_schema(components), 'A2A JSON-RPC 2.0 request'
+        ),
+    }
+    rest_extras = {
+        key: _request_body_extra(
+            message_schema(cls.DESCRIPTOR, components),
+            f'A2A {cls.__name__}',
+            required=key not in _OPTIONAL_REST_BODIES,
+        )
+        for key, cls in REST_BODY_TYPES.items()
+    }
+
+    for route in agent_card_routes or ():
+        _attach_route(app, route, _AGENT_CARD_TAG, openapi_extra=None)
+
+    for route in jsonrpc_routes or ():
+        extra = jsonrpc_extra if isinstance(route, Route) else None
+        _attach_route(
+            app,
+            route,
+            _JSONRPC_TAG,
+            openapi_extra=extra,
+            require_version_header=True,
+        )
+
+    for route in rest_routes or ():
+        extra = (
+            _rest_body_extra(route, rest_extras)
+            if isinstance(route, Route)
+            else None
+        )
+        _attach_route(
+            app,
+            route,
+            _REST_TAG,
+            openapi_extra=extra,
+            require_version_header=True,
+        )
+
+    original_openapi = app.openapi
+
+    def _openapi() -> dict[str, Any]:
+        if app.openapi_schema:
+            return app.openapi_schema
+        schema = original_openapi()
+        component_schemas = schema.setdefault('components', {}).setdefault(
+            'schemas', {}
+        )
+        for name, sub_schema in components.items():
+            component_schemas.setdefault(name, sub_schema)
+        return schema
+
+    app.openapi = _openapi  # type: ignore[method-assign]  # ty: ignore[invalid-assignment]
diff --git a/src/a2a/server/routes/jsonrpc_dispatcher.py b/src/a2a/server/routes/jsonrpc_dispatcher.py
new file mode 100644
index 000000000..fb1801b46
--- /dev/null
+++ b/src/a2a/server/routes/jsonrpc_dispatcher.py
@@ -0,0 +1,621 @@
+"""JSON-RPC application for A2A server."""
+
+import json
+import logging
+
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Any, cast
+
+from google.protobuf.json_format import MessageToDict, ParseDict
+from jsonrpc.jsonrpc2 import JSONRPC20Request, JSONRPC20Response
+
+from a2a.compat.v0_3.jsonrpc_adapter import JSONRPC03Adapter
+from a2a.server.context import ServerCallContext
+from a2a.server.events import Event
+from a2a.server.jsonrpc_models import (
+    InternalError,
+    JSONParseError,
+    JSONRPCError,
+    MethodNotFoundError,
+)
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.request_handlers.response_helpers import build_error_response
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    ServerCallContextBuilder,
+    create_event_source_response,
+    serialize_list_tasks_response,
+)
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    SendMessageRequest,
+    SendMessageResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils import constants, json_utils, proto_utils
+from a2a.utils.errors import (
+    A2AError,
+    InvalidParamsError,
+    InvalidRequestError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
+from a2a.utils.version_validator import validate_version
+
+
+INTERNAL_ERROR_CODE = -32603
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from sse_starlette.sse import EventSourceResponse
+    from starlette.exceptions import HTTPException
+    from starlette.requests import Request
+    from starlette.responses import JSONResponse, Response
+
+    try:
+        # Starlette v0.48.0
+        from starlette.status import HTTP_413_CONTENT_TOO_LARGE
+    except ImportError:
+        from starlette.status import (
+            HTTP_413_REQUEST_ENTITY_TOO_LARGE as HTTP_413_CONTENT_TOO_LARGE,  # type: ignore[no-redef]
+        )
+
+    _package_starlette_installed = True
+else:
+    try:
+        from sse_starlette.sse import EventSourceResponse
+        from starlette.exceptions import HTTPException
+        from starlette.requests import Request
+        from starlette.responses import JSONResponse, Response
+
+        try:
+            # Starlette v0.48.0
+            from starlette.status import HTTP_413_CONTENT_TOO_LARGE
+        except ImportError:
+            from starlette.status import (
+                HTTP_413_REQUEST_ENTITY_TOO_LARGE as HTTP_413_CONTENT_TOO_LARGE,
+            )
+
+        _package_starlette_installed = True
+    except ImportError:
+        _package_starlette_installed = False
+        # Provide placeholder types for runtime type hinting when dependencies are not installed.
+        # These will not be used if the code path that needs them is guarded by _http_server_installed.
+        EventSourceResponse = Any
+        HTTPException = Any
+        Request = Any
+        JSONResponse = Any
+        Response = Any
+        HTTP_413_CONTENT_TOO_LARGE = Any
+
+
+@trace_class(kind=SpanKind.SERVER)
+class JsonRpcDispatcher:
+    """Base class for A2A JSONRPC applications.
+
+    Handles incoming JSON-RPC requests, routes them to the appropriate
+    handler methods, and manages response generation including Server-Sent Events
+    (SSE).
+    """
+
+    # Method-to-model mapping for centralized routing
+    # Proto types don't have model_fields, so we define the mapping explicitly
+    # Method names match gRPC service method names
+    METHOD_TO_MODEL: dict[str, type] = {
+        'SendMessage': SendMessageRequest,
+        'SendStreamingMessage': SendMessageRequest,  # Same proto type as SendMessage
+        'GetTask': GetTaskRequest,
+        'ListTasks': ListTasksRequest,
+        'CancelTask': CancelTaskRequest,
+        'CreateTaskPushNotificationConfig': TaskPushNotificationConfig,
+        'GetTaskPushNotificationConfig': GetTaskPushNotificationConfigRequest,
+        'ListTaskPushNotificationConfigs': ListTaskPushNotificationConfigsRequest,
+        'DeleteTaskPushNotificationConfig': DeleteTaskPushNotificationConfigRequest,
+        'SubscribeToTask': SubscribeToTaskRequest,
+        'GetExtendedAgentCard': GetExtendedAgentCardRequest,
+    }
+
+    def __init__(
+        self,
+        request_handler: RequestHandler,
+        context_builder: ServerCallContextBuilder | None = None,
+        enable_v0_3_compat: bool = False,
+        shutdown_grace_period: float = 0,
+    ) -> None:
+        """Initializes the JsonRpcDispatcher.
+
+        Args:
+            request_handler: The handler instance responsible for processing A2A
+              requests via http.
+            context_builder: The ServerCallContextBuilder used to construct the
+              ServerCallContext passed to the request_handler. If None the
+              DefaultServerCallContextBuilder is used.
+            enable_v0_3_compat: Whether to enable v0.3 backward compatibility on the same endpoint.
+            shutdown_grace_period: Seconds to allow active SSE streams to
+              finish before force-cancellation during shutdown.
+        """
+        if not _package_starlette_installed:
+            raise ImportError(
+                'Packages `starlette` and `sse-starlette` are required to use the'
+                ' `JsonRpcDispatcher`. They can be added as a part of `a2a-sdk`'
+                ' optional dependencies, `a2a-sdk[http-server]`.'
+            )
+
+        self.request_handler = request_handler
+        self._context_builder = (
+            context_builder or DefaultServerCallContextBuilder()
+        )
+        self.enable_v0_3_compat = enable_v0_3_compat
+        self._shutdown_grace_period = shutdown_grace_period
+        self._v03_adapter: JSONRPC03Adapter | None = None
+
+        if self.enable_v0_3_compat:
+            self._v03_adapter = JSONRPC03Adapter(
+                http_handler=request_handler,
+                context_builder=self._context_builder,
+                shutdown_grace_period=shutdown_grace_period,
+            )
+
+    def _generate_error_response(
+        self,
+        request_id: str | int | None,
+        error: Exception | JSONRPCError | A2AError,
+    ) -> JSONResponse:
+        """Creates a Starlette JSONResponse for a JSON-RPC error.
+
+        Logs the error based on its type.
+
+        Args:
+            request_id: The ID of the request that caused the error.
+            error: The error object (one of the JSONRPCError types).
+
+        Returns:
+            A `JSONResponse` object formatted as a JSON-RPC error response.
+        """
+        if not isinstance(error, A2AError | JSONRPCError):
+            error = InternalError(message=str(error))
+
+        response_data = build_error_response(request_id, error)
+        error_info = response_data.get('error', {})
+        code = error_info.get('code')
+        message = error_info.get('message')
+        data = error_info.get('data')
+
+        log_level = logging.WARNING
+        if code == INTERNAL_ERROR_CODE:
+            log_level = logging.ERROR
+
+        logger.log(
+            log_level,
+            "Request Error (ID: %s): Code=%s, Message='%s'%s",
+            request_id,
+            code,
+            message,
+            f', Data={data}' if data else '',
+        )
+        return JSONResponse(
+            response_data,
+            status_code=200,
+        )
+
+    async def handle_requests(self, request: Request) -> Response:  # noqa: PLR0911, PLR0912
+        """Handles incoming POST requests to the main A2A endpoint.
+
+        Parses the request body as JSON, validates it against A2A request types,
+        dispatches it to the appropriate handler method, and returns the response.
+        Handles JSON parsing errors, validation errors, and other exceptions,
+        returning appropriate JSON-RPC error responses.
+
+        Args:
+            request: The incoming Starlette Request object.
+
+        Returns:
+            A Starlette Response object (JSONResponse or EventSourceResponse).
+
+        Raises:
+            (Implicitly handled): Various exceptions are caught and converted
+            into JSON-RPC error responses by this method.
+        """
+        request_id = None
+        body = None
+
+        try:
+            body = await request.json()
+            if isinstance(body, dict):
+                request_id = body.get('id')
+                # Ensure request_id is valid for JSON-RPC response (str/int/None only;
+                # exclude bool since bool is a subclass of int in Python)
+                if isinstance(request_id, bool) or (
+                    request_id is not None
+                    and not isinstance(request_id, str | int)
+                ):
+                    request_id = None
+            logger.debug('Request body: %s', body)
+            # 1) Validate base JSON-RPC structure only (-32600 on failure)
+            try:
+                base_request = JSONRPC20Request.from_data(body)
+                if not isinstance(base_request, JSONRPC20Request):
+                    # Batch requests are not supported
+                    return self._generate_error_response(
+                        request_id,
+                        InvalidRequestError(
+                            message='Batch requests are not supported'
+                        ),
+                    )
+                if body.get('jsonrpc') != '2.0':
+                    return self._generate_error_response(
+                        request_id,
+                        InvalidRequestError(
+                            message="Invalid request: 'jsonrpc' must be exactly '2.0'"
+                        ),
+                    )
+                if isinstance(base_request._id, bool):  # noqa: SLF001
+                    return self._generate_error_response(
+                        request_id,
+                        InvalidRequestError(
+                            message='Invalid request: id must be a string, integer, or null'
+                        ),
+                    )
+            except Exception as e:
+                logger.exception('Failed to validate base JSON-RPC request')
+                return self._generate_error_response(
+                    request_id,
+                    InvalidRequestError(data={'parseError': str(e)}),
+                )
+
+            # 2) Route by method name; unknown -> -32601, known -> validate params (-32602 on failure)
+            method: str | None = base_request.method
+            request_id = base_request._id  # noqa: SLF001
+
+            if not method:
+                return self._generate_error_response(
+                    request_id,
+                    InvalidRequestError(message='Method is required'),
+                )
+
+            if (
+                self.enable_v0_3_compat
+                and self._v03_adapter
+                and self._v03_adapter.supports_method(method)
+            ):
+                return await self._v03_adapter.handle_request(
+                    request_id=request_id,
+                    method=method,
+                    body=body,
+                    request=request,
+                )
+
+            model_class = self.METHOD_TO_MODEL.get(method)
+            if not model_class:
+                return self._generate_error_response(
+                    request_id, MethodNotFoundError()
+                )
+            try:
+                # Unknown fields are ignored for forward compatibility. The
+                # flag also defaults unknown enum values to 0, which protobuf
+                # gives no way to opt out of separately.
+                params = body.get('params', {})
+                specific_request = ParseDict(
+                    params, model_class(), ignore_unknown_fields=True
+                )
+            except Exception as e:
+                logger.exception('Failed to parse request params')
+                return self._generate_error_response(
+                    request_id,
+                    InvalidParamsError(data={'parseError': str(e)}),
+                )
+
+            # 3) Build call context and wrap the request for downstream handling
+            call_context = self._context_builder.build(request)
+            call_context.tenant = getattr(specific_request, 'tenant', '')
+            call_context.state['method'] = method
+            call_context.state['request_id'] = request_id
+
+            # Route streaming requests by method name
+            handler_result: (
+                AsyncGenerator[dict[str, Any], None] | dict[str, Any]
+            )
+            if method in ('SendStreamingMessage', 'SubscribeToTask'):
+                handler_result = await self._process_streaming_request(
+                    request_id, specific_request, call_context
+                )
+            else:
+                try:
+                    raw_result = await self._process_non_streaming_request(
+                        specific_request, call_context
+                    )
+                    handler_result = JSONRPC20Response(
+                        result=raw_result, _id=request_id
+                    ).data
+                except A2AError as e:
+                    handler_result = build_error_response(request_id, e)
+            return self._create_response(call_context, handler_result)
+        except (json.decoder.JSONDecodeError, UnicodeDecodeError) as e:
+            return self._generate_error_response(
+                None, JSONParseError(message=str(e))
+            )
+        except HTTPException as e:
+            if e.status_code == HTTP_413_CONTENT_TOO_LARGE:
+                return self._generate_error_response(
+                    request_id,
+                    InvalidRequestError(message='Payload too large'),
+                )
+            raise e
+        except A2AError as e:
+            return self._generate_error_response(request_id, e)
+        except Exception as e:
+            logger.exception('Unhandled exception')
+            return self._generate_error_response(
+                request_id, InternalError(message=str(e))
+            )
+
+    @validate_version(constants.PROTOCOL_VERSION_1_0)
+    async def _process_streaming_request(
+        self,
+        request_id: str | int | None,
+        request_obj: Any,
+        context: ServerCallContext,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        """Processes streaming requests (SendStreamingMessage or SubscribeToTask).
+
+        Args:
+            request_id: The ID of the request.
+            request_obj: The proto request message.
+            context: The ServerCallContext for the request.
+
+        Returns:
+            An `AsyncGenerator` object to stream results to the client.
+        """
+        stream: AsyncGenerator | None = None
+        method = context.state.get('method')
+        if method == 'SendStreamingMessage':
+            stream = self.request_handler.on_message_send_stream(
+                request_obj, context
+            )
+        elif method == 'SubscribeToTask':
+            stream = self.request_handler.on_subscribe_to_task(
+                request_obj, context
+            )
+
+        if stream is None:
+            raise UnsupportedOperationError(message='Stream not supported')
+
+        # Eagerly fetch the first event to trigger validation/upfront errors
+        try:
+            first_event = await anext(stream)
+        except StopAsyncIteration:
+            first_event = None
+
+        async def _wrap_stream(
+            st: AsyncGenerator, first_evt: Event | None
+        ) -> AsyncGenerator[dict[str, Any], None]:
+            def _map_event(evt: Event) -> dict[str, Any]:
+                stream_response = proto_utils.to_stream_response(evt)
+                result = MessageToDict(
+                    stream_response, preserving_proto_field_name=False
+                )
+                return JSONRPC20Response(result=result, _id=request_id).data
+
+            try:
+                if first_evt is not None:
+                    yield _map_event(first_evt)
+
+                async for event in st:
+                    yield _map_event(event)
+            except A2AError as e:
+                yield build_error_response(request_id, e)
+
+        return _wrap_stream(stream, first_event)
+
+    async def _handle_send_message(
+        self, request_obj: SendMessageRequest, context: ServerCallContext
+    ) -> dict[str, Any]:
+        task_or_message = await self.request_handler.on_message_send(
+            request_obj, context
+        )
+        if isinstance(task_or_message, Task):
+            return MessageToDict(SendMessageResponse(task=task_or_message))
+        return MessageToDict(SendMessageResponse(message=task_or_message))
+
+    async def _handle_cancel_task(
+        self, request_obj: CancelTaskRequest, context: ServerCallContext
+    ) -> dict[str, Any]:
+        task = await self.request_handler.on_cancel_task(request_obj, context)
+        if task:
+            return MessageToDict(task, preserving_proto_field_name=False)
+        raise TaskNotFoundError
+
+    async def _handle_get_task(
+        self, request_obj: GetTaskRequest, context: ServerCallContext
+    ) -> dict[str, Any]:
+        task = await self.request_handler.on_get_task(request_obj, context)
+        if task:
+            return MessageToDict(task, preserving_proto_field_name=False)
+        raise TaskNotFoundError
+
+    async def _handle_list_tasks(
+        self, request_obj: ListTasksRequest, context: ServerCallContext
+    ) -> dict[str, Any]:
+        tasks_response = await self.request_handler.on_list_tasks(
+            request_obj, context
+        )
+        return serialize_list_tasks_response(
+            tasks_response, request_obj.include_artifacts
+        )
+
+    async def _handle_create_task_push_notification_config(
+        self,
+        request_obj: TaskPushNotificationConfig,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        result_config = (
+            await self.request_handler.on_create_task_push_notification_config(
+                request_obj, context
+            )
+        )
+        return MessageToDict(result_config, preserving_proto_field_name=False)
+
+    async def _handle_get_task_push_notification_config(
+        self,
+        request_obj: GetTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        config = (
+            await self.request_handler.on_get_task_push_notification_config(
+                request_obj, context
+            )
+        )
+        return MessageToDict(config, preserving_proto_field_name=False)
+
+    async def _handle_list_task_push_notification_configs(
+        self,
+        request_obj: ListTaskPushNotificationConfigsRequest,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        configs_response = (
+            await self.request_handler.on_list_task_push_notification_configs(
+                request_obj, context
+            )
+        )
+        return MessageToDict(
+            configs_response, preserving_proto_field_name=False
+        )
+
+    async def _handle_delete_task_push_notification_config(
+        self,
+        request_obj: DeleteTaskPushNotificationConfigRequest,
+        context: ServerCallContext,
+    ) -> None:
+        await self.request_handler.on_delete_task_push_notification_config(
+            request_obj, context
+        )
+
+    async def _handle_get_extended_agent_card(
+        self,
+        request_obj: GetExtendedAgentCardRequest,
+        context: ServerCallContext,
+    ) -> dict[str, Any]:
+        card = await self.request_handler.on_get_extended_agent_card(
+            request_obj, context
+        )
+        return MessageToDict(card, preserving_proto_field_name=False)
+
+    @validate_version(constants.PROTOCOL_VERSION_1_0)
+    async def _process_non_streaming_request(  # noqa: PLR0911
+        self,
+        request_obj: Any,
+        context: ServerCallContext,
+    ) -> dict[str, Any] | None:
+        """Processes non-streaming requests.
+
+        Args:
+            request_obj: The proto request message.
+            context: The ServerCallContext for the request.
+
+        Returns:
+            A dict containing the result or error.
+        """
+        method = context.state.get('method')
+        match method:
+            case 'SendMessage':
+                return await self._handle_send_message(request_obj, context)
+            case 'CancelTask':
+                return await self._handle_cancel_task(request_obj, context)
+            case 'GetTask':
+                return await self._handle_get_task(request_obj, context)
+            case 'ListTasks':
+                return await self._handle_list_tasks(request_obj, context)
+            case 'CreateTaskPushNotificationConfig':
+                return await self._handle_create_task_push_notification_config(
+                    request_obj, context
+                )
+            case 'GetTaskPushNotificationConfig':
+                return await self._handle_get_task_push_notification_config(
+                    request_obj, context
+                )
+            case 'ListTaskPushNotificationConfigs':
+                return await self._handle_list_task_push_notification_configs(
+                    request_obj, context
+                )
+            case 'DeleteTaskPushNotificationConfig':
+                await self._handle_delete_task_push_notification_config(
+                    request_obj, context
+                )
+                return None
+            case 'GetExtendedAgentCard':
+                return await self._handle_get_extended_agent_card(
+                    request_obj, context
+                )
+            case _:
+                logger.error('Unhandled method: %s', method)
+                raise UnsupportedOperationError(
+                    message=f'Method {method} is not supported.'
+                )
+
+    def _create_response(
+        self,
+        context: ServerCallContext,
+        handler_result: AsyncGenerator[dict[str, Any]] | dict[str, Any],
+    ) -> Response:
+        """Creates a Starlette Response based on the result from the request handler.
+
+        Handles:
+        - AsyncGenerator for Server-Sent Events (SSE).
+        - Dict responses from handlers.
+
+        Args:
+            context: The ServerCallContext provided to the request handler.
+            handler_result: The result from a request handler method. Can be an
+                async generator for streaming or a dict for non-streaming.
+
+        Returns:
+            A Starlette JSONResponse or EventSourceResponse.
+        """
+        if isinstance(handler_result, AsyncGenerator):
+            # Result is a stream of dict objects
+            async def event_generator(
+                stream: AsyncGenerator[dict[str, Any]],
+            ) -> AsyncGenerator[dict[str, str]]:
+                try:
+                    async for item in stream:
+                        event: dict[str, str] = {
+                            'data': json_utils.dumps(item),
+                        }
+                        if 'error' in item:
+                            event['event'] = 'error'
+                        yield event
+                except Exception as e:
+                    logger.exception(
+                        'Unhandled error during JSON-RPC SSE stream'
+                    )
+                    rpc_error: A2AError | JSONRPCError = (
+                        e
+                        if isinstance(e, A2AError | JSONRPCError)
+                        else InternalError(message=str(e))
+                    )
+                    error_response = build_error_response(
+                        context.state.get('request_id'), rpc_error
+                    )
+                    yield {
+                        'event': 'error',
+                        'data': json_utils.dumps(error_response),
+                    }
+
+            stream = cast('AsyncGenerator[dict[str, Any]]', handler_result)
+            return create_event_source_response(
+                event_generator(stream),
+                shutdown_grace_period=self._shutdown_grace_period,
+            )
+
+        # handler_result is a dict (JSON-RPC response)
+        return JSONResponse(handler_result)
diff --git a/src/a2a/server/routes/jsonrpc_routes.py b/src/a2a/server/routes/jsonrpc_routes.py
new file mode 100644
index 000000000..648e9dfa2
--- /dev/null
+++ b/src/a2a/server/routes/jsonrpc_routes.py
@@ -0,0 +1,74 @@
+import logging
+
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from starlette.routing import Route
+
+    _package_starlette_installed = True
+else:
+    try:
+        from starlette.routing import Route
+
+        _package_starlette_installed = True
+    except ImportError:
+        Route = Any
+
+        _package_starlette_installed = False
+
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes.common import ServerCallContextBuilder
+from a2a.server.routes.jsonrpc_dispatcher import JsonRpcDispatcher
+
+
+logger = logging.getLogger(__name__)
+
+
+def create_jsonrpc_routes(
+    request_handler: RequestHandler,
+    rpc_url: str,
+    context_builder: ServerCallContextBuilder | None = None,
+    enable_v0_3_compat: bool = False,
+    shutdown_grace_period: float = 0,
+) -> list['Route']:
+    """Creates the Starlette Route for the A2A protocol JSON-RPC endpoint.
+
+    Handles incoming JSON-RPC requests, routes them to the appropriate
+    handler methods, and manages response generation including Server-Sent Events
+    (SSE).
+
+    Args:
+        request_handler: The handler instance responsible for processing A2A
+          requests via http.
+        rpc_url: The URL prefix for the RPC endpoints. Should start with a leading slash '/'.
+        context_builder: The ServerCallContextBuilder used to construct the
+          ServerCallContext passed to the request_handler. If None the
+          DefaultServerCallContextBuilder is used.
+        enable_v0_3_compat: Whether to enable v0.3 backward compatibility on the same endpoint.
+        shutdown_grace_period: Seconds to allow active SSE streams to finish
+          before force-cancellation during shutdown. This value should be less
+          than the ASGI server's graceful shutdown timeout. Defaults to 0,
+          matching the ``sse-starlette`` default behavior.
+    """
+    if not _package_starlette_installed:
+        raise ImportError(
+            'The `starlette` package is required to use `create_jsonrpc_routes`.'
+            ' It can be added as a part of `a2a-sdk` optional dependencies,'
+            ' `a2a-sdk[http-server]`.'
+        )
+
+    dispatcher = JsonRpcDispatcher(
+        request_handler=request_handler,
+        context_builder=context_builder,
+        enable_v0_3_compat=enable_v0_3_compat,
+        shutdown_grace_period=shutdown_grace_period,
+    )
+
+    return [
+        Route(
+            path=rpc_url,
+            endpoint=dispatcher.handle_requests,
+            methods=['POST'],
+        )
+    ]
diff --git a/src/a2a/server/routes/rest_dispatcher.py b/src/a2a/server/routes/rest_dispatcher.py
new file mode 100644
index 000000000..80964e5bf
--- /dev/null
+++ b/src/a2a/server/routes/rest_dispatcher.py
@@ -0,0 +1,382 @@
+import logging
+
+from collections.abc import AsyncIterator, Awaitable, Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from google.protobuf.json_format import MessageToDict
+
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    ServerCallContextBuilder,
+    create_event_source_response,
+    serialize_list_tasks_response,
+)
+from a2a.types import a2a_pb2
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    GetTaskPushNotificationConfigRequest,
+    SubscribeToTaskRequest,
+)
+from a2a.utils import constants, json_utils, proto_utils
+from a2a.utils.error_handlers import (
+    build_rest_error_payload,
+    rest_error_handler,
+    rest_stream_error_handler,
+)
+from a2a.utils.errors import (
+    InvalidRequestError,
+    TaskNotFoundError,
+)
+from a2a.utils.telemetry import SpanKind, trace_class
+from a2a.utils.version_validator import validate_version
+
+
+if TYPE_CHECKING:
+    from sse_starlette.event import ServerSentEvent
+    from sse_starlette.sse import EventSourceResponse
+    from starlette.requests import Request
+    from starlette.responses import JSONResponse as A2AJSONResponse
+    from starlette.responses import Response
+
+    _package_starlette_installed = True
+else:
+    try:
+        from sse_starlette.event import ServerSentEvent
+        from sse_starlette.sse import EventSourceResponse
+        from starlette.requests import Request
+        from starlette.responses import JSONResponse, Response
+
+        class A2AJSONResponse(JSONResponse):
+            """JSONResponse labelled with the A2A media type."""
+
+            media_type = constants.A2A_JSON_MEDIA_TYPE
+
+        _package_starlette_installed = True
+    except ImportError:
+        EventSourceResponse = Any
+        ServerSentEvent = Any
+        Request = Any
+        A2AJSONResponse = Any
+        Response = Any
+
+        _package_starlette_installed = False
+
+logger = logging.getLogger(__name__)
+
+TResponse = TypeVar('TResponse')
+
+
+@trace_class(kind=SpanKind.SERVER)
+class RestDispatcher:
+    """Dispatches incoming REST requests to the appropriate handler methods.
+
+    Handles context building, routing to RequestHandler directly, and response formatting (JSON/SSE).
+    """
+
+    def __init__(
+        self,
+        request_handler: RequestHandler,
+        context_builder: ServerCallContextBuilder | None = None,
+        shutdown_grace_period: float = 0,
+    ) -> None:
+        """Initializes the RestDispatcher.
+
+        Args:
+            request_handler: The underlying `RequestHandler` instance to delegate requests to.
+            context_builder: The ServerCallContextBuilder used to construct the
+              ServerCallContext passed to the request_handler. If None the
+              DefaultServerCallContextBuilder is used.
+            shutdown_grace_period: Seconds to allow active SSE streams to
+              finish before force-cancellation during shutdown.
+        """
+        if not _package_starlette_installed:
+            raise ImportError(
+                'Packages `starlette` and `sse-starlette` are required to use the'
+                ' `RestDispatcher`. They can be added as a part of `a2a-sdk` '
+                'optional dependencies, `a2a-sdk[http-server]`.'
+            )
+
+        self._context_builder = (
+            context_builder or DefaultServerCallContextBuilder()
+        )
+        self.request_handler = request_handler
+        self._shutdown_grace_period = shutdown_grace_period
+
+    def _build_call_context(self, request: Request) -> ServerCallContext:
+        call_context = self._context_builder.build(request)
+        if 'tenant' in request.path_params:
+            call_context.tenant = request.path_params['tenant']
+        return call_context
+
+    async def _handle_non_streaming(
+        self,
+        request: Request,
+        handler_func: Callable[[ServerCallContext], Awaitable[TResponse]],
+    ) -> TResponse:
+        """Centralized error handling and context management for unary calls."""
+        context = self._build_call_context(request)
+        return await handler_func(context)
+
+    async def _handle_streaming(
+        self,
+        request: Request,
+        handler_func: Callable[[ServerCallContext], AsyncIterator[Any]],
+    ) -> EventSourceResponse:
+        """Centralized error handling and context management for streaming calls."""
+        # Pre-consume and cache the request body to prevent deadlock in streaming context
+        # This is required because Starlette's request.body() can only be consumed once,
+        # and attempting to consume it after EventSourceResponse starts causes deadlock
+        try:
+            await request.body()
+        except (ValueError, RuntimeError, OSError) as e:
+            raise InvalidRequestError(
+                message=f'Failed to pre-consume request body: {e}'
+            ) from e
+
+        context = self._build_call_context(request)
+
+        # Eagerly fetch the first item from the stream so that errors raised
+        # before any event is yielded (e.g. validation, parsing, or handler
+        # failures) propagate here and are caught by
+        # @rest_stream_error_handler, which returns a JSONResponse with
+        # the correct HTTP status code instead of starting an SSE stream.
+        # Without this, the error would be raised after SSE headers are
+        # already sent, and the client would see a broken stream instead
+        stream = aiter(handler_func(context))
+        try:
+            first_item = await anext(stream)
+        except StopAsyncIteration:
+            return create_event_source_response(
+                iter([]),
+                shutdown_grace_period=self._shutdown_grace_period,
+            )
+
+        async def event_generator() -> AsyncIterator[ServerSentEvent]:
+            yield ServerSentEvent(data=json_utils.dumps(first_item))
+            try:
+                async for item in stream:
+                    yield ServerSentEvent(data=json_utils.dumps(item))
+            except Exception as e:
+                logger.exception('Error during REST SSE stream')
+                yield ServerSentEvent(
+                    data=json_utils.dumps(build_rest_error_payload(e)),
+                    event='error',
+                )
+
+        return create_event_source_response(
+            event_generator(),
+            shutdown_grace_period=self._shutdown_grace_period,
+        )
+
+    @rest_error_handler
+    async def on_message_send(self, request: Request) -> Response:
+        """Handles the 'message/send' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.SendMessageResponse:
+            body = await request.body()
+            params = a2a_pb2.SendMessageRequest()
+            proto_utils.parse_lenient(body, params)
+            task_or_message = await self.request_handler.on_message_send(
+                params, context
+            )
+            if isinstance(task_or_message, a2a_pb2.Task):
+                return a2a_pb2.SendMessageResponse(task=task_or_message)
+            return a2a_pb2.SendMessageResponse(message=task_or_message)
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_stream_error_handler
+    async def on_message_send_stream(
+        self, request: Request
+    ) -> EventSourceResponse:
+        """Handles the 'message/stream' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> AsyncIterator[dict[str, Any]]:
+            body = await request.body()
+            params = a2a_pb2.SendMessageRequest()
+            proto_utils.parse_lenient(body, params)
+            async for event in self.request_handler.on_message_send_stream(
+                params, context
+            ):
+                response = proto_utils.to_stream_response(event)
+                yield MessageToDict(response)
+
+        return await self._handle_streaming(request, _handler)
+
+    @rest_error_handler
+    async def on_cancel_task(self, request: Request) -> Response:
+        """Handles the 'tasks/cancel' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(context: ServerCallContext) -> a2a_pb2.Task:
+            params = CancelTaskRequest()
+            body = await request.body()
+            if body.strip():
+                proto_utils.parse_lenient(body, params)
+            params.id = request.path_params['id']
+            task = await self.request_handler.on_cancel_task(params, context)
+            if task:
+                return task
+            raise TaskNotFoundError
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_stream_error_handler
+    async def on_subscribe_to_task(
+        self, request: Request
+    ) -> EventSourceResponse:
+        """Handles the 'SubscribeToTask' REST method."""
+        task_id = request.path_params['id']
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> AsyncIterator[dict[str, Any]]:
+            async for event in self.request_handler.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=task_id), context
+            ):
+                response = proto_utils.to_stream_response(event)
+                yield MessageToDict(response)
+
+        return await self._handle_streaming(request, _handler)
+
+    @rest_error_handler
+    async def on_get_task(self, request: Request) -> Response:
+        """Handles the 'tasks/{id}' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(context: ServerCallContext) -> a2a_pb2.Task:
+            params = a2a_pb2.GetTaskRequest()
+            proto_utils.parse_params(request.query_params, params)
+            params.id = request.path_params['id']
+            task = await self.request_handler.on_get_task(params, context)
+            if task:
+                return task
+            raise TaskNotFoundError
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_error_handler
+    async def get_push_notification(self, request: Request) -> Response:
+        """Handles the 'tasks/pushNotificationConfig/get' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.TaskPushNotificationConfig:
+            task_id = request.path_params['id']
+            push_id = request.path_params['push_id']
+            params = GetTaskPushNotificationConfigRequest(
+                task_id=task_id, id=push_id
+            )
+            return (
+                await self.request_handler.on_get_task_push_notification_config(
+                    params, context
+                )
+            )
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_error_handler
+    async def delete_push_notification(self, request: Request) -> Response:
+        """Handles the 'tasks/pushNotificationConfig/delete' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(context: ServerCallContext) -> None:
+            task_id = request.path_params['id']
+            push_id = request.path_params['push_id']
+            params = a2a_pb2.DeleteTaskPushNotificationConfigRequest(
+                task_id=task_id, id=push_id
+            )
+            await self.request_handler.on_delete_task_push_notification_config(
+                params, context
+            )
+
+        await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content={})
+
+    @rest_error_handler
+    async def set_push_notification(self, request: Request) -> Response:
+        """Handles the 'tasks/pushNotificationConfig/set' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.TaskPushNotificationConfig:
+            body = await request.body()
+            params = a2a_pb2.TaskPushNotificationConfig()
+            proto_utils.parse_lenient(body, params)
+            params.task_id = request.path_params['id']
+            return await self.request_handler.on_create_task_push_notification_config(
+                params, context
+            )
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_error_handler
+    async def list_push_notifications(self, request: Request) -> Response:
+        """Handles the 'tasks/pushNotificationConfig/list' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.ListTaskPushNotificationConfigsResponse:
+            params = a2a_pb2.ListTaskPushNotificationConfigsRequest()
+            proto_utils.parse_params(request.query_params, params)
+            params.task_id = request.path_params['id']
+            return await self.request_handler.on_list_task_push_notification_configs(
+                params, context
+            )
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
+
+    @rest_error_handler
+    async def list_tasks(self, request: Request) -> Response:
+        """Handles the 'tasks/list' REST method."""
+        params = a2a_pb2.ListTasksRequest()
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.ListTasksResponse:
+            proto_utils.parse_params(request.query_params, params)
+            return await self.request_handler.on_list_tasks(params, context)
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(
+            content=serialize_list_tasks_response(
+                response, params.include_artifacts
+            )
+        )
+
+    @rest_error_handler
+    async def handle_authenticated_agent_card(
+        self, request: Request
+    ) -> Response:
+        """Handles the 'agentCard' REST method."""
+
+        @validate_version(constants.PROTOCOL_VERSION_1_0)
+        async def _handler(
+            context: ServerCallContext,
+        ) -> a2a_pb2.AgentCard:
+            params = a2a_pb2.GetExtendedAgentCardRequest()
+            return await self.request_handler.on_get_extended_agent_card(
+                params, context
+            )
+
+        response = await self._handle_non_streaming(request, _handler)
+        return A2AJSONResponse(content=MessageToDict(response))
diff --git a/src/a2a/server/routes/rest_routes.py b/src/a2a/server/routes/rest_routes.py
new file mode 100644
index 000000000..b74141189
--- /dev/null
+++ b/src/a2a/server/routes/rest_routes.py
@@ -0,0 +1,125 @@
+import logging
+
+from typing import TYPE_CHECKING, Any
+
+from a2a.compat.v0_3.rest_adapter import REST03Adapter
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes.common import ServerCallContextBuilder
+from a2a.server.routes.rest_dispatcher import RestDispatcher
+
+
+if TYPE_CHECKING:
+    from starlette.routing import BaseRoute, Mount, Route
+
+    _package_starlette_installed = True
+else:
+    try:
+        from starlette.routing import BaseRoute, Mount, Route
+
+        _package_starlette_installed = True
+    except ImportError:
+        Route = Any
+        Mount = Any
+        BaseRoute = Any
+
+        _package_starlette_installed = False
+
+logger = logging.getLogger(__name__)
+
+
+def create_rest_routes(
+    request_handler: RequestHandler,
+    context_builder: ServerCallContextBuilder | None = None,
+    enable_v0_3_compat: bool = False,
+    path_prefix: str = '',
+    shutdown_grace_period: float = 0,
+) -> list['BaseRoute']:
+    """Creates the Starlette Routes for the A2A protocol REST endpoint.
+
+    Args:
+        request_handler: The handler instance responsible for processing A2A
+          requests via http.
+        context_builder: The ServerCallContextBuilder used to construct the
+          ServerCallContext passed to the request_handler. If None the
+          DefaultServerCallContextBuilder is used.
+        enable_v0_3_compat: If True, mounts backward-compatible v0.3 protocol
+          endpoints using REST03Adapter.
+        path_prefix: The URL prefix for the REST endpoints.
+        shutdown_grace_period: Seconds to allow active SSE streams to finish
+          before force-cancellation during shutdown. This value should be less
+          than the ASGI server's graceful shutdown timeout. Defaults to 0,
+          matching the ``sse-starlette`` default behavior.
+    """
+    if not _package_starlette_installed:
+        raise ImportError(
+            'Packages `starlette` and `sse-starlette` are required to use'
+            ' the `create_rest_routes`. They can be added as a part of `a2a-sdk` '
+            'optional dependencies, `a2a-sdk[http-server]`.'
+        )
+
+    dispatcher = RestDispatcher(
+        request_handler=request_handler,
+        context_builder=context_builder,
+        shutdown_grace_period=shutdown_grace_period,
+    )
+
+    routes: list[BaseRoute] = []
+    if enable_v0_3_compat:
+        v03_adapter = REST03Adapter(
+            http_handler=request_handler,
+            context_builder=context_builder,
+            shutdown_grace_period=shutdown_grace_period,
+        )
+        v03_routes = v03_adapter.routes()
+        for (path, method), endpoint in v03_routes.items():
+            routes.append(
+                Route(
+                    path=f'{path_prefix}{path}',
+                    endpoint=endpoint,
+                    methods=[method],
+                )
+            )
+
+    base_routes = {
+        ('/message:send', 'POST'): dispatcher.on_message_send,
+        ('/message:stream', 'POST'): dispatcher.on_message_send_stream,
+        ('/tasks/{id}:cancel', 'POST'): dispatcher.on_cancel_task,
+        ('/tasks/{id}:subscribe', 'GET'): dispatcher.on_subscribe_to_task,
+        ('/tasks/{id}:subscribe', 'POST'): dispatcher.on_subscribe_to_task,
+        ('/tasks/{id}', 'GET'): dispatcher.on_get_task,
+        (
+            '/tasks/{id}/pushNotificationConfigs/{push_id}',
+            'GET',
+        ): dispatcher.get_push_notification,
+        (
+            '/tasks/{id}/pushNotificationConfigs/{push_id}',
+            'DELETE',
+        ): dispatcher.delete_push_notification,
+        (
+            '/tasks/{id}/pushNotificationConfigs',
+            'POST',
+        ): dispatcher.set_push_notification,
+        (
+            '/tasks/{id}/pushNotificationConfigs',
+            'GET',
+        ): dispatcher.list_push_notifications,
+        ('/tasks', 'GET'): dispatcher.list_tasks,
+        (
+            '/extendedAgentCard',
+            'GET',
+        ): dispatcher.handle_authenticated_agent_card,
+    }
+
+    base_route_objects = []
+    for (path, method), endpoint in base_routes.items():
+        base_route_objects.append(
+            Route(
+                path=f'{path_prefix}{path}',
+                endpoint=endpoint,
+                methods=[method],
+            )
+        )
+    routes.extend(base_route_objects)
+    routes.append(Mount(path='/{tenant}', routes=base_route_objects))
+
+    return routes
diff --git a/src/a2a/server/tasks/__init__.py b/src/a2a/server/tasks/__init__.py
index d61df11f0..cf18b01a6 100644
--- a/src/a2a/server/tasks/__init__.py
+++ b/src/a2a/server/tasks/__init__.py
@@ -1,12 +1,82 @@
+"""Components for managing tasks within the A2A server."""
+
+import logging
+
+from a2a.server.tasks.base_push_notification_sender import (
+    BasePushNotificationSender,
+)
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
 from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.tasks.push_notification_config_store import (
+    PushNotificationConfigStore,
+)
+from a2a.server.tasks.push_notification_sender import (
+    PushNotificationEvent,
+    PushNotificationSender,
+)
 from a2a.server.tasks.result_aggregator import ResultAggregator
 from a2a.server.tasks.task_manager import TaskManager
 from a2a.server.tasks.task_store import TaskStore
 from a2a.server.tasks.task_updater import TaskUpdater
 
 
+logger = logging.getLogger(__name__)
+
+try:
+    from a2a.server.tasks.database_task_store import (
+        DatabaseTaskStore,
+    )
+except ImportError as e:
+    _original_error = e
+    # If the database task store is not available, we can still use in-memory stores.
+    logger.debug(
+        'DatabaseTaskStore not loaded. This is expected if database dependencies are not installed. Error: %s',
+        e,
+    )
+
+    class DatabaseTaskStore:
+        """Placeholder for DatabaseTaskStore when dependencies are not installed."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                'To use DatabaseTaskStore, its dependencies must be installed. '
+                'You can install them with \'pip install "a2a-sdk[sql]"\''
+            ) from _original_error
+
+
+try:
+    from a2a.server.tasks.database_push_notification_config_store import (
+        DatabasePushNotificationConfigStore,
+    )
+except ImportError as e:
+    _original_error = e
+    # If the database push notification config store is not available, we can still use in-memory stores.
+    logger.debug(
+        'DatabasePushNotificationConfigStore not loaded. This is expected if database dependencies are not installed. Error: %s',
+        e,
+    )
+
+    class DatabasePushNotificationConfigStore:
+        """Placeholder for DatabasePushNotificationConfigStore when dependencies are not installed."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                'To use DatabasePushNotificationConfigStore, its dependencies must be installed. '
+                'You can install them with \'pip install "a2a-sdk[sql]"\''
+            ) from _original_error
+
+
 __all__ = [
+    'BasePushNotificationSender',
+    'DatabasePushNotificationConfigStore',
+    'DatabaseTaskStore',
+    'InMemoryPushNotificationConfigStore',
     'InMemoryTaskStore',
+    'PushNotificationConfigStore',
+    'PushNotificationEvent',
+    'PushNotificationSender',
     'ResultAggregator',
     'TaskManager',
     'TaskStore',
diff --git a/src/a2a/server/tasks/base_push_notification_sender.py b/src/a2a/server/tasks/base_push_notification_sender.py
new file mode 100644
index 000000000..bade95752
--- /dev/null
+++ b/src/a2a/server/tasks/base_push_notification_sender.py
@@ -0,0 +1,222 @@
+import asyncio
+import logging
+import time
+
+from collections.abc import Awaitable, Callable
+
+import httpx
+
+from google.protobuf.json_format import MessageToDict
+
+from a2a.plugins.manager import PluginManager, get_global
+from a2a.plugins.types import PushRequest, PushResult
+from a2a.server.context import ServerCallContext
+from a2a.server.tasks.push_notification_config_store import (
+    PushNotificationConfigStore,
+)
+from a2a.server.tasks.push_notification_sender import (
+    PushNotificationEvent,
+    PushNotificationSender,
+)
+from a2a.types.a2a_pb2 import TaskPushNotificationConfig
+from a2a.utils.proto_utils import to_stream_response
+
+
+logger = logging.getLogger(__name__)
+
+
+class BasePushNotificationSender(PushNotificationSender):
+    """Base implementation of PushNotificationSender interface."""
+
+    def __init__(
+        self,
+        httpx_client: httpx.AsyncClient,
+        config_store: PushNotificationConfigStore,
+        context: ServerCallContext | None = None,
+        *,
+        push_url_validator: Callable[[str], Awaitable[bool]] | None = None,
+        plugins: PluginManager | None = None,
+    ) -> None:
+        """Initializes the BasePushNotificationSender.
+
+        Args:
+            httpx_client: An async HTTP client instance to send notifications.
+            config_store: A PushNotificationConfigStore instance to
+              retrieve configurations.
+            context: Deprecated and ignored. Accepted only for
+              backward compatibility with 1.0 callers that constructed
+              the sender with a (typically dummy) ServerCallContext.
+              Pass None (the default) in new code. A non-None
+              value logs a deprecation warning and is otherwise
+              ignored.
+            push_url_validator: Async callable that returns True to
+              accept a push URL, or False to reject it. Defaults to
+              None (no library screening). The spec lists these checks
+              as SHOULD, so deployments that want the built-in policy
+              should pass ``validate_push_notification_url``.
+            plugins: Plugin manager whose `PushPlugin` hooks run for every
+              delivery, whichever request handler uses this sender.
+              Defaults to the global manager at construction time; it is
+              independent of the manager passed to the request handler.
+        """
+        if context is not None:
+            logger.warning(
+                'BasePushNotificationSender no longer uses the context '
+                'parameter; it is accepted only for backward compatibility '
+                'with 1.0 and will be removed in a future major version. '
+                'Push notifications now fan out across all owners via '
+                'PushNotificationConfigStore.get_info_for_dispatch; the '
+                'caller identity is not carried into dispatch. Drop the '
+                'context argument from the constructor call.'
+            )
+        self._client = httpx_client
+        self._config_store = config_store
+        self._push_url_validator = push_url_validator
+        self._plugins = plugins if plugins is not None else get_global()
+
+    async def send_notification(
+        self, task_id: str, event: PushNotificationEvent
+    ) -> None:
+        """Sends a push notification for an event if configuration exists.
+
+        Best-effort by design: failures to read the configuration store or
+        to deliver a notification are logged and do not raise.
+        """
+        try:
+            push_configs = await self._config_store.get_info_for_dispatch(
+                task_id
+            )
+        except Exception:
+            # Push delivery is best-effort: an infrastructure failure while
+            # reading the config store must not propagate into the task
+            # lifecycle.
+            logger.exception(
+                'Failed to read push notification configs for task_id=%s; '
+                'skipping push notification delivery.',
+                task_id,
+            )
+            return
+        if not push_configs:
+            return
+
+        awaitables = [
+            self._dispatch_notification(event, push_info, task_id)
+            for push_info in push_configs
+        ]
+        results = await asyncio.gather(*awaitables)
+
+        if not all(results):
+            logger.warning(
+                'Some push notifications failed to send for task_id=%s', task_id
+            )
+
+    async def _dispatch_notification(
+        self,
+        event: PushNotificationEvent,
+        push_info: TaskPushNotificationConfig,
+        task_id: str,
+    ) -> bool:
+        url = push_info.url
+        if self._push_url_validator is not None:
+            try:
+                accepted = await self._push_url_validator(url)
+            except Exception:
+                logger.exception(
+                    'Push URL validator raised for task_id=%s, URL: %s. '
+                    'Failing closed and treating the URL as rejected.',
+                    task_id,
+                    url,
+                )
+                return False
+            if not accepted:
+                return False
+        plugins = self._plugins if self._plugins.has_push_hooks else None
+        request = PushRequest(
+            task_id, url, self._build_headers(push_info, task_id), event
+        )
+
+        if plugins is not None:
+            # before_push_send may add headers or set request.skip. The
+            # validated URL is captured above and cannot be redirected.
+            try:
+                await plugins.before_push_send(request)
+            except Exception as e:
+                logger.exception(
+                    'Push plugin failed before sending for task_id=%s to '
+                    'URL: %s.',
+                    task_id,
+                    url,
+                )
+                await self._report(plugins, PushResult(request, 0.0, None, e))
+                return False
+            if request.skip:
+                logger.debug(
+                    'Push-notification for task_id=%s to URL: %s skipped by a '
+                    'plugin',
+                    task_id,
+                    url,
+                )
+                await self._report(
+                    plugins, PushResult(request, 0.0, None, None, skipped=True)
+                )
+                return True
+
+        start = time.monotonic()
+        status_code: int | None = None
+        error: Exception | None = None
+        try:
+            response = await self._client.post(
+                url,
+                json=MessageToDict(to_stream_response(event)),
+                headers=request.headers,
+            )
+            status_code = response.status_code
+            response.raise_for_status()
+        except Exception as e:
+            error = e
+            logger.exception(
+                'Error sending push-notification for task_id=%s to URL: %s.',
+                task_id,
+                url,
+            )
+        else:
+            logger.info(
+                'Push-notification sent for task_id=%s to URL: %s', task_id, url
+            )
+        if plugins is not None:
+            await self._report(
+                plugins,
+                PushResult(
+                    request, time.monotonic() - start, status_code, error
+                ),
+            )
+        return error is None
+
+    def _build_headers(
+        self, push_info: TaskPushNotificationConfig, task_id: str
+    ) -> dict[str, str]:
+        """Builds the delivery headers from the push config."""
+        headers: dict[str, str] = {}
+        if push_info.token:
+            headers['X-A2A-Notification-Token'] = push_info.token
+        auth = push_info.authentication
+        if push_info.HasField('authentication'):
+            if auth.scheme and auth.credentials:
+                headers['Authorization'] = f'{auth.scheme} {auth.credentials}'
+            elif auth.scheme:
+                logger.warning(
+                    'Push config %s sets an authentication scheme with no '
+                    'credentials; sending no Authorization header for '
+                    'task_id=%s',
+                    push_info.id,
+                    task_id,
+                )
+        return headers
+
+    @staticmethod
+    async def _report(plugins: PluginManager, result: PushResult) -> None:
+        """Calls on_push_sent, keeping a raising manager from failing delivery."""
+        try:
+            await plugins.on_push_sent(result)
+        except Exception:
+            logger.exception('Push plugin failed in on_push_sent')
diff --git a/src/a2a/server/tasks/copying_task_store.py b/src/a2a/server/tasks/copying_task_store.py
new file mode 100644
index 000000000..f7f41bf1f
--- /dev/null
+++ b/src/a2a/server/tasks/copying_task_store.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from a2a.server.context import ServerCallContext
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types.a2a_pb2 import ListTasksRequest, ListTasksResponse, Task
+
+
+logger = logging.getLogger(__name__)
+
+
+class CopyingTaskStoreAdapter(TaskStore):
+    """An adapter that ensures deep copies of tasks are passed to and returned from the underlying TaskStore.
+
+    This prevents accidental shared mutable state bugs where code modifies a Task object
+    retrieved from the store without explicitly saving it, which hides missing save calls.
+    """
+
+    def __init__(self, underlying_store: TaskStore):
+        self._store = underlying_store
+
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        """Saves a copy of the task to the underlying store."""
+        task_copy = Task()
+        task_copy.CopyFrom(task)
+        await self._store.save(task_copy, context)
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> Task | None:
+        """Retrieves a task from the underlying store and returns a copy."""
+        task = await self._store.get(task_id, context)
+        if task is None:
+            return None
+        task_copy = Task()
+        task_copy.CopyFrom(task)
+        return task_copy
+
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Retrieves a list of tasks from the underlying store and returns a copy."""
+        response = await self._store.list(params, context)
+        response_copy = ListTasksResponse()
+        response_copy.CopyFrom(response)
+        return response_copy
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the underlying store."""
+        await self._store.delete(task_id, context)
diff --git a/src/a2a/server/tasks/database_push_notification_config_store.py b/src/a2a/server/tasks/database_push_notification_config_store.py
new file mode 100644
index 000000000..ce5979095
--- /dev/null
+++ b/src/a2a/server/tasks/database_push_notification_config_store.py
@@ -0,0 +1,417 @@
+# ruff: noqa: PLC0415
+import logging
+
+from typing import TYPE_CHECKING
+
+from google.protobuf.json_format import MessageToJson, Parse
+
+
+try:
+    from sqlalchemy import ColumnElement, Table, and_, delete, select
+    from sqlalchemy.ext.asyncio import (
+        AsyncEngine,
+        AsyncSession,
+        async_sessionmaker,
+    )
+    from sqlalchemy.orm import class_mapper
+except ImportError as e:
+    raise ImportError(
+        'DatabasePushNotificationConfigStore requires SQLAlchemy and a database driver. '
+        'Install with one of: '
+        "'pip install a2a-sdk[postgresql]', "
+        "'pip install a2a-sdk[mysql]', "
+        "'pip install a2a-sdk[sqlite]', "
+        "or 'pip install a2a-sdk[sql]'"
+    ) from e
+
+from collections.abc import Callable
+
+from a2a.compat.v0_3.model_conversions import (
+    compat_push_notification_config_model_to_core,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.models import (
+    Base,
+    PushNotificationConfigModel,
+    create_push_notification_config_model,
+)
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.tasks.push_notification_config_store import (
+    PushNotificationConfigStore,
+    normalize_push_notification_config,
+)
+from a2a.types.a2a_pb2 import TaskPushNotificationConfig
+
+
+if TYPE_CHECKING:
+    from cryptography.fernet import Fernet
+
+logger = logging.getLogger(__name__)
+
+
+class DatabasePushNotificationConfigStore(PushNotificationConfigStore):
+    """SQLAlchemy-based implementation of PushNotificationConfigStore.
+
+    Stores push notification configurations in a database supported by SQLAlchemy.
+    """
+
+    engine: AsyncEngine
+    async_session_maker: async_sessionmaker[AsyncSession]
+    create_table: bool
+    _initialized: bool
+    config_model: type[PushNotificationConfigModel]
+    _fernet: 'Fernet | None'
+    owner_resolver: OwnerResolver
+    core_to_model_conversion: (
+        Callable[
+            [str, TaskPushNotificationConfig, str, 'Fernet | None'],
+            PushNotificationConfigModel,
+        ]
+        | None
+    )
+    model_to_core_conversion: (
+        Callable[[PushNotificationConfigModel], TaskPushNotificationConfig]
+        | None
+    )
+
+    def __init__(  # noqa: PLR0913
+        self,
+        engine: AsyncEngine,
+        create_table: bool = True,
+        table_name: str = 'push_notification_configs',
+        encryption_key: str | bytes | None = None,
+        owner_resolver: OwnerResolver = resolve_user_scope,
+        core_to_model_conversion: Callable[
+            [str, TaskPushNotificationConfig, str, 'Fernet | None'],
+            PushNotificationConfigModel,
+        ]
+        | None = None,
+        model_to_core_conversion: Callable[
+            [PushNotificationConfigModel], TaskPushNotificationConfig
+        ]
+        | None = None,
+    ) -> None:
+        """Initializes the DatabasePushNotificationConfigStore.
+
+        Args:
+            engine: An existing SQLAlchemy AsyncEngine to be used by the store.
+            create_table: If true, create the table on initialization.
+            table_name: Name of the database table. Defaults to 'push_notification_configs'.
+            encryption_key: A key for encrypting sensitive configuration data.
+                If provided, `config_data` will be encrypted in the database.
+                The key must be a URL-safe base64-encoded 32-byte key.
+            owner_resolver: Function to resolve the owner from the context.
+            core_to_model_conversion: Optional function to convert a TaskPushNotificationConfig to a TaskPushNotificationConfigModel.
+            model_to_core_conversion: Optional function to convert a TaskPushNotificationConfigModel to a TaskPushNotificationConfig.
+        """
+        logger.debug(
+            'Initializing DatabasePushNotificationConfigStore with existing engine, table: %s',
+            table_name,
+        )
+        self.engine = engine
+        self.async_session_maker = async_sessionmaker(
+            self.engine, expire_on_commit=False
+        )
+        self.create_table = create_table
+        self._initialized = False
+        self.owner_resolver = owner_resolver
+        self.config_model = (  # ty:ignore[invalid-assignment]
+            PushNotificationConfigModel
+            if table_name == 'push_notification_configs'
+            else create_push_notification_config_model(table_name)
+        )
+        self._fernet = None
+        self.core_to_model_conversion = core_to_model_conversion
+        self.model_to_core_conversion = model_to_core_conversion
+
+        if encryption_key:
+            try:
+                from cryptography.fernet import (
+                    Fernet,
+                )
+            except ImportError as e:
+                raise ImportError(
+                    "DatabasePushNotificationConfigStore with encryption requires the 'cryptography' "
+                    'library. Install with: '
+                    "'pip install a2a-sdk[encryption]'"
+                ) from e
+
+            if isinstance(encryption_key, str):
+                encryption_key = encryption_key.encode('utf-8')
+            self._fernet = Fernet(encryption_key)
+            logger.debug(
+                'Encryption enabled for push notification config store.'
+            )
+
+    async def initialize(self) -> None:
+        """Initialize the database and create the table if needed."""
+        if self._initialized:
+            return
+
+        logger.debug(
+            'Initializing database schema for push notification configs...'
+        )
+        if self.create_table:
+            async with self.engine.begin() as conn:
+                mapper = class_mapper(self.config_model)
+                tables_to_create = [
+                    table for table in mapper.tables if isinstance(table, Table)
+                ]
+                await conn.run_sync(
+                    Base.metadata.create_all, tables=tables_to_create
+                )
+        self._initialized = True
+        logger.debug(
+            'Database schema for push notification configs initialized.'
+        )
+
+    async def _ensure_initialized(self) -> None:
+        """Ensure the database connection is initialized."""
+        if not self._initialized:
+            await self.initialize()
+
+    def _to_orm(
+        self, task_id: str, config: TaskPushNotificationConfig, owner: str
+    ) -> PushNotificationConfigModel:
+        """Maps a TaskPushNotificationConfig proto to a SQLAlchemy model instance.
+
+        The config data is serialized to JSON bytes, and encrypted if a key is configured.
+        """
+        if self.core_to_model_conversion:
+            return self.core_to_model_conversion(
+                task_id, config, owner, self._fernet
+            )
+
+        json_payload = MessageToJson(config).encode('utf-8')
+
+        if self._fernet:
+            data_to_store = self._fernet.encrypt(json_payload)
+        else:
+            data_to_store = json_payload
+
+        return self.config_model(
+            task_id=task_id,
+            config_id=config.id,
+            owner=owner,
+            config_data=data_to_store,
+            protocol_version='1.0',
+        )
+
+    def _from_orm(
+        self, model_instance: PushNotificationConfigModel
+    ) -> TaskPushNotificationConfig:
+        """Maps a SQLAlchemy model instance to a TaskPushNotificationConfig proto.
+
+        Handles decryption if a key is configured, with a fallback to plain JSON.
+        """
+        if self.model_to_core_conversion:
+            return self.model_to_core_conversion(model_instance)
+
+        payload = model_instance.config_data
+
+        if self._fernet:
+            from cryptography.fernet import (
+                InvalidToken,
+            )
+
+            try:
+                decrypted_payload = self._fernet.decrypt(payload)
+                return self._parse_config(
+                    decrypted_payload.decode('utf-8'),
+                    model_instance.task_id,
+                    model_instance.protocol_version,
+                )
+            except Exception as e:
+                if isinstance(e, InvalidToken):
+                    # Decryption failed. This could be because the data is not encrypted.
+                    # We'll log a warning and try to parse it as plain JSON as a fallback.
+                    logger.warning(
+                        'Failed to decrypt push notification config for task %s, config %s. '
+                        'Attempting to parse as unencrypted JSON. '
+                        'This may indicate an incorrect encryption key or unencrypted data in the database.',
+                        model_instance.task_id,
+                        model_instance.config_id,
+                    )
+                    # Fall through to the unencrypted parsing logic below.
+                else:
+                    logger.exception(
+                        'Failed to parse decrypted push notification config for task %s, config %s. '
+                        'Data is corrupted or not valid JSON after decryption.',
+                        model_instance.task_id,
+                        model_instance.config_id,
+                    )
+                    raise ValueError(  # noqa: TRY004
+                        'Failed to parse decrypted push notification config data'
+                    ) from e
+
+        # Try to parse as plain JSON.
+        try:
+            payload_str = (
+                payload.decode('utf-8')
+                if isinstance(payload, bytes)
+                else payload
+            )
+            return self._parse_config(
+                payload_str,
+                model_instance.task_id,
+                model_instance.protocol_version,
+            )
+
+        except Exception as e:
+            if self._fernet:
+                logger.exception(
+                    'Failed to parse push notification config for task %s, config %s. '
+                    'Decryption failed and the data is not valid JSON. '
+                    'This likely indicates the data is corrupted or encrypted with a different key.',
+                    model_instance.task_id,
+                    model_instance.config_id,
+                )
+            else:
+                # if no key is configured and the payload is not valid JSON.
+                logger.exception(
+                    'Failed to parse push notification config for task %s, config %s. '
+                    'Data is not valid JSON and no encryption key is configured.',
+                    model_instance.task_id,
+                    model_instance.config_id,
+                )
+            raise ValueError(
+                'Failed to parse push notification config data. '
+                'Data is not valid JSON, or it is encrypted with the wrong key.'
+            ) from e
+
+    async def set_info(
+        self,
+        task_id: str,
+        notification_config: TaskPushNotificationConfig,
+        context: ServerCallContext,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a task."""
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+
+        config_to_save = normalize_push_notification_config(
+            task_id, notification_config
+        )
+
+        db_config = self._to_orm(task_id, config_to_save, owner)
+        async with self.async_session_maker.begin() as session:
+            await session.merge(db_config)
+            logger.debug(
+                'Push notification config for task %s with config id %s for owner %s saved/updated.',
+                task_id,
+                config_to_save.id,
+                owner,
+            )
+        return config_to_save
+
+    async def _select_configs(
+        self,
+        *predicates: 'ColumnElement[bool]',
+    ) -> list[TaskPushNotificationConfig]:
+        """Loads configs matching the given predicates and decodes them."""
+        await self._ensure_initialized()
+        async with self.async_session_maker() as session:
+            stmt = select(self.config_model).where(and_(*predicates))
+            result = await session.execute(stmt)
+            models = result.scalars().all()
+
+            configs = []
+            for model in models:
+                try:
+                    configs.append(self._from_orm(model))
+                except ValueError:  # noqa: PERF203
+                    logger.exception(
+                        'Could not deserialize push notification config for task %s, config %s, owner %s',
+                        model.task_id,
+                        model.config_id,
+                        model.owner,
+                    )
+            return configs
+
+    async def get_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves all push notification configurations for a task, for the given owner.
+
+        Used by the user-callable read endpoints.
+        """
+        owner = self.owner_resolver(context)
+        return await self._select_configs(
+            self.config_model.task_id == task_id,
+            self.config_model.owner == owner,
+        )
+
+    async def get_info_for_dispatch(
+        self,
+        task_id: str,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves all push notification configurations for a task, across all owners.
+
+        Used by the push-notification dispatch path.
+        """
+        return await self._select_configs(
+            self.config_model.task_id == task_id,
+        )
+
+    async def delete_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+        config_id: str | None = None,
+    ) -> None:
+        """Deletes push notification configurations for a task.
+
+        If config_id is provided, only that specific configuration is deleted.
+        If config_id is None, all configurations for the task for the owner are deleted.
+        """
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+        async with self.async_session_maker.begin() as session:
+            stmt = delete(self.config_model).where(
+                and_(
+                    self.config_model.task_id == task_id,
+                    self.config_model.owner == owner,
+                )
+            )
+            if config_id is not None:
+                stmt = stmt.where(self.config_model.config_id == config_id)
+
+            result = await session.execute(stmt)
+
+            if result.rowcount > 0:  # ty:ignore[unresolved-attribute]
+                logger.info(
+                    'Deleted %s push notification config(s) for task %s, owner %s.',
+                    result.rowcount,  # ty:ignore[unresolved-attribute]
+                    task_id,
+                    owner,
+                )
+            else:
+                logger.warning(
+                    'Attempted to delete push notification config for task %s, owner %s with config_id: %s that does not exist.',
+                    task_id,
+                    owner,
+                    config_id,
+                )
+
+    def _parse_config(
+        self,
+        json_payload: str,
+        task_id: str | None = None,
+        protocol_version: str | None = None,
+    ) -> TaskPushNotificationConfig:
+        """Parses a JSON payload into a TaskPushNotificationConfig proto.
+
+        Args:
+            json_payload: The JSON payload to parse.
+            task_id: The unique identifier of the task. Only required for legacy
+                (0.3) protocol versions.
+            protocol_version: The protocol version used for serialization.
+        """
+        if protocol_version == '1.0':
+            return Parse(json_payload, TaskPushNotificationConfig())
+
+        return compat_push_notification_config_model_to_core(
+            json_payload, task_id or ''
+        )
diff --git a/src/a2a/server/tasks/database_task_store.py b/src/a2a/server/tasks/database_task_store.py
new file mode 100644
index 000000000..0e41ce13e
--- /dev/null
+++ b/src/a2a/server/tasks/database_task_store.py
@@ -0,0 +1,417 @@
+import logging
+
+from collections.abc import Callable
+from datetime import datetime
+from typing import Any, cast
+
+
+try:
+    from sqlalchemy import Table, and_, case, delete, func, or_, select
+    from sqlalchemy.ext.asyncio import (
+        AsyncEngine,
+        AsyncSession,
+        async_sessionmaker,
+    )
+    from sqlalchemy.orm import class_mapper
+except ImportError as e:
+    raise ImportError(
+        'DatabaseTaskStore requires SQLAlchemy and a database driver. '
+        'Install with one of: '
+        "'pip install a2a-sdk[postgresql]', "
+        "'pip install a2a-sdk[mysql]', "
+        "'pip install a2a-sdk[sqlite]', "
+        "or 'pip install a2a-sdk[sql]'"
+    ) from e
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from a2a.compat.v0_3.conversions import to_compat_task_status
+from a2a.compat.v0_3.model_conversions import (
+    compat_task_model_to_core,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.models import Base, TaskModel, create_task_model
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types import a2a_pb2
+from a2a.types.a2a_pb2 import Task
+from a2a.utils.constants import DEFAULT_LIST_TASKS_PAGE_SIZE
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.task import (
+    ListTasksCursor,
+    decode_list_tasks_cursor,
+    decode_page_token,
+    encode_list_tasks_cursor,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+def _datetime_to_ns(value: datetime) -> int:
+    """Nanoseconds since the epoch for a stored (naive UTC) `last_updated`."""
+    timestamp = Timestamp()
+    timestamp.FromDatetime(value)
+    return timestamp.ToNanoseconds()
+
+
+def _ns_to_datetime(timestamp_ns: int) -> datetime:
+    """Inverse of `_datetime_to_ns`, as a naive UTC datetime."""
+    timestamp = Timestamp()
+    timestamp.FromNanoseconds(timestamp_ns)
+    return timestamp.ToDatetime()
+
+
+class DatabaseTaskStore(TaskStore):
+    """SQLAlchemy-based implementation of TaskStore.
+
+    Stores task objects in a database supported by SQLAlchemy.
+    """
+
+    engine: AsyncEngine
+    async_session_maker: async_sessionmaker[AsyncSession]
+    create_table: bool
+    _initialized: bool
+    task_model: type[TaskModel]
+    owner_resolver: OwnerResolver
+    core_to_model_conversion: Callable[[Task, str], TaskModel] | None = None
+    model_to_core_conversion: Callable[[TaskModel], Task] | None = None
+
+    def __init__(  # noqa: PLR0913
+        self,
+        engine: AsyncEngine,
+        create_table: bool = True,
+        table_name: str = 'tasks',
+        owner_resolver: OwnerResolver = resolve_user_scope,
+        core_to_model_conversion: Callable[[Task, str], TaskModel]
+        | None = None,
+        model_to_core_conversion: Callable[[TaskModel], Task] | None = None,
+    ) -> None:
+        """Initializes the DatabaseTaskStore.
+
+        Args:
+            engine: An existing SQLAlchemy AsyncEngine to be used by Task Store
+            create_table: If true, create tasks table on initialization.
+            table_name: Name of the database table. Defaults to 'tasks'.
+            owner_resolver: Function to resolve the owner from the context.
+            core_to_model_conversion: Optional function to convert a Task to a TaskModel.
+            model_to_core_conversion: Optional function to convert a TaskModel to a Task.
+        """
+        logger.debug(
+            'Initializing DatabaseTaskStore with existing engine, table: %s',
+            table_name,
+        )
+        self.engine = engine
+        self.async_session_maker = async_sessionmaker(
+            self.engine, expire_on_commit=False
+        )
+        self.create_table = create_table
+        self._initialized = False
+        self.owner_resolver = owner_resolver
+        self.core_to_model_conversion = core_to_model_conversion
+        self.model_to_core_conversion = model_to_core_conversion
+
+        self.task_model = (  # ty:ignore[invalid-assignment]
+            TaskModel
+            if table_name == 'tasks'
+            else create_task_model(table_name)
+        )
+
+    async def initialize(self) -> None:
+        """Initialize the database and create the table if needed."""
+        if self._initialized:
+            return
+
+        logger.debug('Initializing database schema...')
+        if self.create_table:
+            async with self.engine.begin() as conn:
+                mapper = class_mapper(self.task_model)
+                tables_to_create = [
+                    table for table in mapper.tables if isinstance(table, Table)
+                ]
+                await conn.run_sync(
+                    Base.metadata.create_all, tables=tables_to_create
+                )
+        self._initialized = True
+        logger.debug('Database schema initialized.')
+
+    async def _ensure_initialized(self) -> None:
+        """Ensure the database connection is initialized."""
+        if not self._initialized:
+            await self.initialize()
+
+    def _to_orm(self, task: Task, owner: str) -> TaskModel:
+        """Maps a Proto Task to a SQLAlchemy TaskModel instance."""
+        if self.core_to_model_conversion:
+            return self.core_to_model_conversion(task, owner)
+
+        return self.task_model(
+            id=task.id,
+            context_id=task.context_id,
+            kind='task',  # Default kind for tasks
+            owner=owner,
+            last_updated=(
+                task.status.timestamp.ToDatetime()
+                if task.status.HasField('timestamp')
+                else None
+            ),
+            status=MessageToDict(task.status),
+            artifacts=[MessageToDict(artifact) for artifact in task.artifacts],
+            history=[MessageToDict(history) for history in task.history],
+            task_metadata=(
+                MessageToDict(task.metadata) if task.metadata.fields else None
+            ),
+            protocol_version='1.0',
+        )
+
+    def _from_orm(self, task_model: TaskModel) -> Task:
+        """Maps a SQLAlchemy TaskModel to a Proto Task instance."""
+        if self.model_to_core_conversion:
+            return self.model_to_core_conversion(task_model)
+
+        if task_model.protocol_version == '1.0':
+            task = Task(
+                id=task_model.id,
+                context_id=task_model.context_id,
+            )
+            # These JSON columns are annotated with proto types but hold plain
+            # dicts at rest; ParseDict wants the dict view.
+            if task_model.status:
+                ParseDict(
+                    cast('dict[str, Any]', task_model.status), task.status
+                )
+            if task_model.artifacts:
+                for art_dict in task_model.artifacts:
+                    art = task.artifacts.add()
+                    ParseDict(cast('dict[str, Any]', art_dict), art)
+            if task_model.history:
+                for msg_dict in task_model.history:
+                    msg = task.history.add()
+                    ParseDict(cast('dict[str, Any]', msg_dict), msg)
+            if task_model.task_metadata:
+                task.metadata.update(task_model.task_metadata)
+            return task
+
+        # Legacy conversion
+        return compat_task_model_to_core(task_model)
+
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        """Saves or updates a task in the database for the resolved owner."""
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+        db_task = self._to_orm(task, owner)
+        async with self.async_session_maker.begin() as session:
+            await session.merge(db_task)
+            logger.debug(
+                'Task %s for owner %s saved/updated successfully.',
+                task.id,
+                owner,
+            )
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> Task | None:
+        """Retrieves a task from the database by ID, for the given owner."""
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+        async with self.async_session_maker() as session:
+            stmt = select(self.task_model).where(
+                and_(
+                    self.task_model.id == task_id,
+                    self.task_model.owner == owner,
+                )
+            )
+            result = await session.execute(stmt)
+            task_model = result.scalar_one_or_none()
+            if task_model:
+                task = self._from_orm(task_model)
+                logger.debug(
+                    'Task %s retrieved successfully for owner %s.',
+                    task_id,
+                    owner,
+                )
+                return task
+
+            logger.debug(
+                'Task %s not found in store for owner %s.', task_id, owner
+            )
+            return None
+
+    async def list(
+        self,
+        params: a2a_pb2.ListTasksRequest,
+        context: ServerCallContext,
+    ) -> a2a_pb2.ListTasksResponse:
+        """Retrieves tasks from the database based on provided parameters, for the given owner."""
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+        logger.debug('Listing tasks for owner %s with params %s', owner, params)
+
+        async with self.async_session_maker() as session:
+            timestamp_col = self.task_model.last_updated
+            base_stmt = select(self.task_model).where(
+                self.task_model.owner == owner
+            )
+
+            # Add filters
+            if params.context_id:
+                base_stmt = base_stmt.where(
+                    self.task_model.context_id == params.context_id
+                )
+            if params.status:
+                base_stmt = base_stmt.where(
+                    self.task_model.status['state']
+                    .as_string()
+                    .in_(
+                        [
+                            a2a_pb2.TaskState.Name(params.status),
+                            to_compat_task_status(
+                                a2a_pb2.TaskStatus(state=params.status)
+                            ).state.value,
+                        ]
+                    )
+                )
+            if params.HasField('status_timestamp_after'):
+                last_updated_after = params.status_timestamp_after.ToDatetime()
+                base_stmt = base_stmt.where(timestamp_col >= last_updated_after)
+
+            # Get total count
+            count_stmt = select(func.count()).select_from(base_stmt.alias())
+            total_count = (await session.execute(count_stmt)).scalar_one()
+
+            # Sort NULL timestamps last without binding a sentinel value, which
+            # may fall outside a database's supported datetime range.
+            stmt = base_stmt.order_by(
+                case((timestamp_col.is_(None), 1), else_=0).asc(),
+                timestamp_col.desc(),
+                self.task_model.id.desc(),
+            )
+
+            # Get paginated results. The page token carries the position of the
+            # last task returned, so it stays valid if that task is updated or
+            # deleted. A task updated mid-listing can move above the cursor and
+            # be skipped.
+            if params.page_token:
+                cursor = decode_list_tasks_cursor(params.page_token)
+                if cursor is None:
+                    stmt = stmt.where(
+                        await self._legacy_page_clause(
+                            session, owner, params.page_token
+                        )
+                    )
+                else:
+                    stmt = stmt.where(self._after_cursor(cursor))
+
+            page_size = params.page_size or DEFAULT_LIST_TASKS_PAGE_SIZE
+            stmt = stmt.limit(page_size + 1)  # Add 1 for next page token
+
+            result = await session.execute(stmt)
+            tasks_models = result.scalars().all()
+            page_models = tasks_models[:page_size]
+
+            next_page_token = (
+                encode_list_tasks_cursor(self._cursor_for(page_models[-1]))
+                if len(tasks_models) == page_size + 1
+                else None
+            )
+
+            return a2a_pb2.ListTasksResponse(
+                tasks=[
+                    self._from_orm(task_model) for task_model in page_models
+                ],
+                total_size=total_count,
+                next_page_token=next_page_token,
+                page_size=page_size,
+            )
+
+    @staticmethod
+    def _cursor_for(task_model: TaskModel) -> ListTasksCursor:
+        # From the stored column, not the proto, so the cursor compares equal
+        # at the database's own timestamp precision.
+        last_updated = task_model.last_updated
+        return ListTasksCursor(
+            timestamp_ns=_datetime_to_ns(last_updated)
+            if last_updated is not None
+            else None,
+            task_id=task_model.id,
+        )
+
+    def _after_cursor(self, cursor: ListTasksCursor) -> Any:
+        """Rows strictly after `cursor` in the `ListTasks` sort order."""
+        timestamp_col = self.task_model.last_updated
+        if cursor.timestamp_ns is None:
+            return and_(
+                timestamp_col.is_(None), self.task_model.id < cursor.task_id
+            )
+        try:
+            cursor_timestamp = _ns_to_datetime(cursor.timestamp_ns)
+        except (OverflowError, ValueError) as e:
+            raise InvalidParamsError('Invalid page token') from e
+        return or_(
+            timestamp_col < cursor_timestamp,
+            and_(
+                timestamp_col == cursor_timestamp,
+                self.task_model.id < cursor.task_id,
+            ),
+            timestamp_col.is_(None),
+        )
+
+    async def _legacy_page_clause(
+        self, session: AsyncSession, owner: str, page_token: str
+    ) -> Any:
+        """Resolves a legacy page token, which names the first task of the page."""
+        timestamp_col = self.task_model.last_updated
+        start_task_id = decode_page_token(page_token)
+        start_task = (
+            await session.execute(
+                select(self.task_model).where(
+                    and_(
+                        self.task_model.id == start_task_id,
+                        self.task_model.owner == owner,
+                    )
+                )
+            )
+        ).scalar_one_or_none()
+        if not start_task:
+            raise InvalidParamsError(f'Invalid page token: {page_token}')
+
+        start_task_timestamp = start_task.last_updated
+        if start_task_timestamp:
+            return or_(
+                and_(
+                    timestamp_col == start_task_timestamp,
+                    self.task_model.id <= start_task_id,
+                ),
+                timestamp_col < start_task_timestamp,
+                timestamp_col.is_(None),
+            )
+        return and_(
+            timestamp_col.is_(None),
+            self.task_model.id <= start_task_id,
+        )
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the database by ID, for the given owner."""
+        await self._ensure_initialized()
+        owner = self.owner_resolver(context)
+
+        async with self.async_session_maker.begin() as session:
+            stmt = delete(self.task_model).where(
+                and_(
+                    self.task_model.id == task_id,
+                    self.task_model.owner == owner,
+                )
+            )
+            result = await session.execute(stmt)
+            # Commit is automatic when using session.begin()
+
+            if result.rowcount > 0:  # ty:ignore[unresolved-attribute]
+                logger.info(
+                    'Task %s deleted successfully for owner %s.', task_id, owner
+                )
+            else:
+                logger.warning(
+                    'Attempted to delete nonexistent task with id: %s and owner %s',
+                    task_id,
+                    owner,
+                )
diff --git a/src/a2a/server/tasks/inmemory_push_notification_config_store.py b/src/a2a/server/tasks/inmemory_push_notification_config_store.py
new file mode 100644
index 000000000..29cbcfc34
--- /dev/null
+++ b/src/a2a/server/tasks/inmemory_push_notification_config_store.py
@@ -0,0 +1,157 @@
+import logging
+import threading
+
+from a2a.server.context import ServerCallContext
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.tasks.push_notification_config_store import (
+    PushNotificationConfigStore,
+    normalize_push_notification_config,
+)
+from a2a.types.a2a_pb2 import TaskPushNotificationConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+class InMemoryPushNotificationConfigStore(PushNotificationConfigStore):
+    """In-memory implementation of PushNotificationConfigStore interface.
+
+    Stores push notification configurations in a nested dictionary in memory,
+    keyed by owner then task_id.
+    """
+
+    def __init__(
+        self,
+        owner_resolver: OwnerResolver = resolve_user_scope,
+    ) -> None:
+        """Initializes the InMemoryPushNotificationConfigStore."""
+        self.lock = threading.RLock()
+        self._push_notification_infos: dict[
+            str, dict[str, list[TaskPushNotificationConfig]]
+        ] = {}
+        self.owner_resolver = owner_resolver
+
+    def _get_owner_push_notification_infos(
+        self, owner: str
+    ) -> dict[str, list[TaskPushNotificationConfig]]:
+        return self._push_notification_infos.get(owner, {})
+
+    async def set_info(
+        self,
+        task_id: str,
+        notification_config: TaskPushNotificationConfig,
+        context: ServerCallContext,
+    ) -> TaskPushNotificationConfig:
+        """Sets or updates the push notification configuration for a task in memory."""
+        owner = self.owner_resolver(context)
+        stored = normalize_push_notification_config(
+            task_id, notification_config
+        )
+
+        with self.lock:
+            owner_infos = self._push_notification_infos.setdefault(owner, {})
+            if task_id not in owner_infos:
+                owner_infos[task_id] = []
+
+            # Remove existing config with the same ID
+            for config in owner_infos[task_id]:
+                if config.id == stored.id:
+                    owner_infos[task_id].remove(config)
+                    break
+
+            owner_infos[task_id].append(stored)
+            logger.debug(
+                'Push notification config for task %s with config id %s for owner %s saved/updated.',
+                task_id,
+                stored.id,
+                owner,
+            )
+
+        result = TaskPushNotificationConfig()
+        result.CopyFrom(stored)
+        return result
+
+    async def get_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves all push notification configurations for a task from memory, for the given owner.
+
+        Used by the user-callable read endpoints.
+        """
+        owner = self.owner_resolver(context)
+        with self.lock:
+            owner_infos = self._get_owner_push_notification_infos(owner)
+            return list(owner_infos.get(task_id, []))
+
+    async def get_info_for_dispatch(
+        self,
+        task_id: str,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves all push notification configurations for a task across all owners.
+
+        Used by the push-notification dispatch path.
+        """
+        with self.lock:
+            results: list[TaskPushNotificationConfig] = []
+            for all_configs in self._push_notification_infos.values():
+                results.extend(all_configs.get(task_id, []))
+            return results
+
+    async def delete_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+        config_id: str | None = None,
+    ) -> None:
+        """Deletes push notification configurations for a task from memory.
+
+        If config_id is provided, only that specific configuration is deleted.
+        If config_id is None, all configurations for the task for the owner are deleted.
+        """
+        owner = self.owner_resolver(context)
+        with self.lock:
+            owner_infos = self._get_owner_push_notification_infos(owner)
+            if task_id not in owner_infos:
+                logger.warning(
+                    'Attempted to delete push notification config for task %s, owner %s that does not exist.',
+                    task_id,
+                    owner,
+                )
+                return
+
+            if config_id is None:
+                del owner_infos[task_id]
+                logger.info(
+                    'Deleted all push notification configs for task %s, owner %s.',
+                    task_id,
+                    owner,
+                )
+            else:
+                configurations = owner_infos[task_id]
+                found = False
+                for config in configurations:
+                    if config.id == config_id:
+                        configurations.remove(config)
+                        found = True
+                        break
+                if found:
+                    logger.info(
+                        'Deleted push notification config %s for task %s, owner %s.',
+                        config_id,
+                        task_id,
+                        owner,
+                    )
+                    if len(configurations) == 0:
+                        del owner_infos[task_id]
+                else:
+                    logger.warning(
+                        'Attempted to delete push notification config %s for task %s, owner %s that does not exist.',
+                        config_id,
+                        task_id,
+                        owner,
+                    )
+
+            if not owner_infos:
+                del self._push_notification_infos[owner]
diff --git a/src/a2a/server/tasks/inmemory_task_store.py b/src/a2a/server/tasks/inmemory_task_store.py
index b3053e876..e264fe73a 100644
--- a/src/a2a/server/tasks/inmemory_task_store.py
+++ b/src/a2a/server/tasks/inmemory_task_store.py
@@ -1,43 +1,256 @@
-import asyncio
 import logging
+import threading
 
+from collections.abc import Sequence
+
+from a2a.server.context import ServerCallContext
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.tasks.copying_task_store import CopyingTaskStoreAdapter
 from a2a.server.tasks.task_store import TaskStore
-from a2a.types import Task
+from a2a.types import a2a_pb2
+from a2a.types.a2a_pb2 import Task
+from a2a.utils.constants import DEFAULT_LIST_TASKS_PAGE_SIZE
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.task import (
+    ListTasksCursor,
+    decode_list_tasks_cursor,
+    decode_page_token,
+    encode_list_tasks_cursor,
+)
 
 
 logger = logging.getLogger(__name__)
 
 
-class InMemoryTaskStore(TaskStore):
-    """In-memory implementation of TaskStore."""
-
-    def __init__(self) -> None:
-        logger.debug('Initializing InMemoryTaskStore')
-        self.tasks: dict[str, Task] = {}
-        self.lock = asyncio.Lock()
-
-    async def save(self, task: Task) -> None:
-        async with self.lock:
-            self.tasks[task.id] = task
-            logger.info('Task %s saved successfully.', task.id)
-
-    async def get(self, task_id: str) -> Task | None:
-        async with self.lock:
-            logger.debug('Attempting to get task with id: %s', task_id)
-            task = self.tasks.get(task_id)
+def _list_sort_key(task: Task) -> tuple[bool, int, str]:
+    """`ListTasks` sort key: `(has timestamp, timestamp, id)`, sorted descending."""
+    has_timestamp = task.HasField('status') and task.status.HasField(
+        'timestamp'
+    )
+    return (
+        has_timestamp,
+        task.status.timestamp.ToNanoseconds() if has_timestamp else 0,
+        task.id,
+    )
+
+
+def _cursor_for(task: Task) -> ListTasksCursor:
+    has_timestamp, timestamp_ns, task_id = _list_sort_key(task)
+    return ListTasksCursor(
+        timestamp_ns=timestamp_ns if has_timestamp else None, task_id=task_id
+    )
+
+
+class _InMemoryTaskStoreImpl(TaskStore):
+    """Internal In-memory implementation of TaskStore.
+
+    Stores task objects in a nested dictionary in memory, keyed by owner then task_id.
+    Task data is lost when the server process stops.
+    """
+
+    def __init__(
+        self,
+        owner_resolver: OwnerResolver = resolve_user_scope,
+    ) -> None:
+        """Initializes the internal _InMemoryTaskStoreImpl."""
+        logger.debug('Initializing _InMemoryTaskStoreImpl')
+        self.tasks: dict[str, dict[str, Task]] = {}
+        self.lock = threading.RLock()
+        self.owner_resolver = owner_resolver
+
+    def _get_owner_tasks(self, owner: str) -> dict[str, Task]:
+        return self.tasks.get(owner, {})
+
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        """Saves or updates a task in the in-memory store for the resolved owner."""
+        owner = self.owner_resolver(context)
+        with self.lock:
+            owner_tasks = self.tasks.setdefault(owner, {})
+            owner_tasks[task.id] = task
+            logger.debug(
+                'Task %s for owner %s saved successfully.', task.id, owner
+            )
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> Task | None:
+        """Retrieves a task from the in-memory store by ID, for the given owner."""
+        owner = self.owner_resolver(context)
+        with self.lock:
+            logger.debug(
+                'Attempting to get task with id: %s for owner: %s',
+                task_id,
+                owner,
+            )
+            owner_tasks = self._get_owner_tasks(owner)
+            task = owner_tasks.get(task_id)
             if task:
-                logger.debug('Task %s retrieved successfully.', task_id)
-            else:
-                logger.debug('Task %s not found in store.', task_id)
-            return task
-
-    async def delete(self, task_id: str) -> None:
-        async with self.lock:
-            logger.debug('Attempting to delete task with id: %s', task_id)
-            if task_id in self.tasks:
-                del self.tasks[task_id]
-                logger.info('Task %s deleted successfully.', task_id)
+                logger.debug(
+                    'Task %s retrieved successfully for owner %s.',
+                    task_id,
+                    owner,
+                )
+                return task
+            logger.debug(
+                'Task %s not found in store for owner %s.', task_id, owner
+            )
+            return None
+
+    async def list(
+        self,
+        params: a2a_pb2.ListTasksRequest,
+        context: ServerCallContext,
+    ) -> a2a_pb2.ListTasksResponse:
+        """Retrieves a list of tasks from the store, for the given owner."""
+        owner = self.owner_resolver(context)
+        logger.debug('Listing tasks for owner %s with params %s', owner, params)
+
+        with self.lock:
+            owner_tasks = self._get_owner_tasks(owner)
+            tasks = list(owner_tasks.values())
+
+        # Filter tasks
+        if params.context_id:
+            tasks = [
+                task for task in tasks if task.context_id == params.context_id
+            ]
+        if params.status:
+            tasks = [
+                task for task in tasks if task.status.state == params.status
+            ]
+        if params.HasField('status_timestamp_after'):
+            last_updated_after_ns = (
+                params.status_timestamp_after.ToNanoseconds()
+            )
+            tasks = [
+                task
+                for task in tasks
+                if (
+                    task.HasField('status')
+                    and task.status.HasField('timestamp')
+                    and task.status.timestamp.ToNanoseconds()
+                    >= last_updated_after_ns
+                )
+            ]
+
+        # Order tasks by last update time. To ensure stable sorting, in cases where timestamps are null or not unique, do a second order comparison of IDs.
+        tasks.sort(key=_list_sort_key, reverse=True)
+
+        # Paginate tasks. The page token carries the position of the last task
+        # returned, so it stays valid if that task is updated or deleted. A
+        # task updated mid-listing can move above the cursor and be skipped.
+        total_size = len(tasks)
+        start_idx = 0
+        if params.page_token:
+            cursor = decode_list_tasks_cursor(params.page_token)
+            if cursor is None:
+                start_idx = self._legacy_start_index(tasks, params.page_token)
             else:
+                after = cursor.sort_key()
+                start_idx = next(
+                    (
+                        i
+                        for i, task in enumerate(tasks)
+                        if _list_sort_key(task) < after
+                    ),
+                    total_size,
+                )
+        page_size = params.page_size or DEFAULT_LIST_TASKS_PAGE_SIZE
+        end_idx = start_idx + page_size
+        next_page_token = (
+            encode_list_tasks_cursor(_cursor_for(tasks[end_idx - 1]))
+            if end_idx < total_size
+            else None
+        )
+        tasks = tasks[start_idx:end_idx]
+
+        return a2a_pb2.ListTasksResponse(
+            next_page_token=next_page_token,
+            tasks=tasks,
+            total_size=total_size,
+            page_size=page_size,
+        )
+
+    @staticmethod
+    def _legacy_start_index(tasks: Sequence[Task], page_token: str) -> int:
+        """Resolves a legacy page token, which names the first task of the page."""
+        start_task_id = decode_page_token(page_token)
+        for i, task in enumerate(tasks):
+            if task.id == start_task_id:
+                return i
+        raise InvalidParamsError(f'Invalid page token: {page_token}')
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the in-memory store by ID, for the given owner."""
+        owner = self.owner_resolver(context)
+        with self.lock:
+            logger.debug(
+                'Attempting to delete task with id: %s for owner %s',
+                task_id,
+                owner,
+            )
+
+            owner_tasks = self._get_owner_tasks(owner)
+            if task_id not in owner_tasks:
                 logger.warning(
-                    'Attempted to delete nonexistent task with id: %s', task_id
+                    'Attempted to delete nonexistent task with id: %s for owner %s',
+                    task_id,
+                    owner,
                 )
+                return
+
+            del owner_tasks[task_id]
+            logger.debug(
+                'Task %s deleted successfully for owner %s.', task_id, owner
+            )
+            if not owner_tasks:
+                del self.tasks[owner]
+                logger.debug('Removed empty owner %s from store.', owner)
+
+
+class InMemoryTaskStore(TaskStore):
+    """In-memory implementation of TaskStore.
+
+    Can optionally use CopyingTaskStoreAdapter to wrap the internal dictionary-based
+    implementation, preventing shared mutable state issues by always returning and
+    storing deep copies.
+    """
+
+    def __init__(
+        self,
+        owner_resolver: OwnerResolver = resolve_user_scope,
+        use_copying: bool = True,
+    ) -> None:
+        """Initializes the InMemoryTaskStore.
+
+        Args:
+            owner_resolver: Resolver for task owners.
+            use_copying: If True, the store will return and save deep copies of tasks.
+              Copying behavior is consistent with database task stores.
+        """
+        self._impl = _InMemoryTaskStoreImpl(owner_resolver=owner_resolver)
+        self._store: TaskStore = (
+            CopyingTaskStoreAdapter(self._impl) if use_copying else self._impl
+        )
+
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        """Saves or updates a task in the store."""
+        await self._store.save(task, context)
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> Task | None:
+        """Retrieves a task from the store by ID."""
+        return await self._store.get(task_id, context)
+
+    async def list(
+        self,
+        params: a2a_pb2.ListTasksRequest,
+        context: ServerCallContext,
+    ) -> a2a_pb2.ListTasksResponse:
+        """Retrieves a list of tasks from the store."""
+        return await self._store.list(params, context)
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the store by ID."""
+        await self._store.delete(task_id, context)
diff --git a/src/a2a/server/tasks/push_notification_config_store.py b/src/a2a/server/tasks/push_notification_config_store.py
new file mode 100644
index 000000000..06a2726e5
--- /dev/null
+++ b/src/a2a/server/tasks/push_notification_config_store.py
@@ -0,0 +1,96 @@
+import logging
+
+from abc import ABC, abstractmethod
+
+from a2a.server.context import ServerCallContext
+from a2a.types.a2a_pb2 import TaskPushNotificationConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+def normalize_push_notification_config(
+    task_id: str, notification_config: TaskPushNotificationConfig
+) -> TaskPushNotificationConfig:
+    """Returns a copy with task_id set and an empty id defaulted to the task id."""
+    normalized = TaskPushNotificationConfig()
+    normalized.CopyFrom(notification_config)
+    normalized.task_id = task_id
+    if not normalized.id:
+        normalized.id = task_id
+    return normalized
+
+
+class PushNotificationConfigStore(ABC):
+    """Interface for storing and retrieving push notification configurations for tasks."""
+
+    @abstractmethod
+    async def set_info(
+        self,
+        task_id: str,
+        notification_config: TaskPushNotificationConfig,
+        context: ServerCallContext,
+    ) -> TaskPushNotificationConfig | None:
+        """Sets or updates the push notification configuration for a task.
+
+        Implementations should not mutate notification_config. They store a
+        copy normalized by normalize_push_notification_config and return it.
+        Returning None is still accepted for existing implementations; the
+        request handlers then normalize the request themselves.
+        """
+
+    @abstractmethod
+    async def get_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves push notification configurations for a task, scoped to the caller.
+
+        This is the user-callable read path. Implementations MUST return
+        only configurations owned by the caller (as resolved from
+        context).
+        """
+
+    async def get_info_for_dispatch(
+        self,
+        task_id: str,
+    ) -> list[TaskPushNotificationConfig]:
+        """Retrieves all push notification configurations for a task, across all owners.
+
+        This is the internal read path used by the push-notification
+        dispatch loop. Implementations SHOULD override this method to
+        return every configuration registered for task_id regardless of
+        which user registered it. Authorization already happened at
+        registration time and the dispatch path fires every registered
+        webhook for the task.
+
+        The default implementation falls back to calling get_info with
+        a synthetic empty ServerCallContext. This preserves 1.0
+        behavior for subclasses that have not implemented the override
+        but is INCORRECT for any deployment with multiple owners: the
+        empty context resolves to the empty-string owner partition and
+        returns no configs (silently dropping every notification). A
+        warning is logged on every call to flag the misconfiguration.
+        Custom subclasses MUST override this method to deliver
+        notifications correctly in multi-owner deployments.
+        """
+        logger.warning(
+            '%s does not override '
+            'PushNotificationConfigStore.get_info_for_dispatch; falling back '
+            'to a context-less get_info call which silently drops '
+            'notifications in any deployment with multiple owners. Override '
+            'get_info_for_dispatch to return all configs for task_id across '
+            'every owner.',
+            type(self).__name__,
+        )
+        return await self.get_info(task_id, ServerCallContext())
+
+    @abstractmethod
+    async def delete_info(
+        self,
+        task_id: str,
+        context: ServerCallContext,
+        config_id: str | None = None,
+    ) -> None:
+        """Deletes the push notification configuration for a task."""
diff --git a/src/a2a/server/tasks/push_notification_sender.py b/src/a2a/server/tasks/push_notification_sender.py
new file mode 100644
index 000000000..679f59102
--- /dev/null
+++ b/src/a2a/server/tasks/push_notification_sender.py
@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+from a2a.types.a2a_pb2 import (
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskStatusUpdateEvent,
+)
+
+
+PushNotificationEvent = Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+
+
+class PushNotificationSender(ABC):
+    """Interface for sending push notifications for tasks."""
+
+    @abstractmethod
+    async def send_notification(
+        self, task_id: str, event: PushNotificationEvent
+    ) -> None:
+        """Sends a push notification containing the latest task state.
+
+        Implementations are treated as best-effort: the framework catches
+        and logs any exception raised here, so a failure never affects the
+        task lifecycle or the event stream.
+        """
diff --git a/src/a2a/server/tasks/result_aggregator.py b/src/a2a/server/tasks/result_aggregator.py
index 9220fc861..32a323a4a 100644
--- a/src/a2a/server/tasks/result_aggregator.py
+++ b/src/a2a/server/tasks/result_aggregator.py
@@ -1,11 +1,12 @@
 import asyncio
 import logging
-from collections.abc import AsyncGenerator, AsyncIterator
-from typing import Tuple
+
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 
 from a2a.server.events import Event, EventConsumer
 from a2a.server.tasks.task_manager import TaskManager
-from a2a.types import Message, Task, TaskState, TaskStatusUpdateEvent
+from a2a.types.a2a_pb2 import Message, Task, TaskState, TaskStatusUpdateEvent
+
 
 logger = logging.getLogger(__name__)
 
@@ -23,20 +24,48 @@ class ResultAggregator:
        Task object and emit that Task object.
     """
 
-    def __init__(self, task_manager: TaskManager):
+    def __init__(
+        self,
+        task_manager: TaskManager,
+    ) -> None:
+        """Initializes the ResultAggregator.
+
+        Args:
+            task_manager: The `TaskManager` instance to use for processing events
+                          and managing the task state.
+        """
         self.task_manager = task_manager
         self._message: Message | None = None
 
     @property
     async def current_result(self) -> Task | Message | None:
+        """Returns the current aggregated result (Task or Message).
+
+        This is the latest state processed from the event stream.
+
+        Returns:
+            The current `Task` object managed by the `TaskManager`, or the final
+            `Message` if one was received, or `None` if no result has been produced yet.
+        """
         if self._message:
             return self._message
         return await self.task_manager.get_task()
 
     async def consume_and_emit(
         self, consumer: EventConsumer
-    ) -> AsyncGenerator[Event, None]:
-        """Processes the event stream and emits the same event stream out."""
+    ) -> AsyncGenerator[Event]:
+        """Processes the event stream from the consumer, updates the task state, and re-emits the same events.
+
+        Useful for streaming scenarios where the server needs to observe and
+        process events (e.g., save task state, send push notifications) while
+        forwarding them to the client.
+
+        Args:
+            consumer: The `EventConsumer` to read events from.
+
+        Yields:
+            The `Event` objects consumed from the `EventConsumer`.
+        """
         async for event in consumer.consume_all():
             await self.task_manager.process(event)
             yield event
@@ -44,7 +73,20 @@ async def consume_and_emit(
     async def consume_all(
         self, consumer: EventConsumer
     ) -> Task | Message | None:
-        """Processes the entire event stream and returns the final result."""
+        """Processes the entire event stream from the consumer and returns the final result.
+
+        Blocks until the event stream ends (queue is closed after final event or exception).
+
+        Args:
+            consumer: The `EventConsumer` to read events from.
+
+        Returns:
+            The final `Task` object or `Message` object after the stream is exhausted.
+            Returns `None` if the stream ends without producing a final result.
+
+        Raises:
+            BaseException: If the `EventConsumer` raises an exception during consumption.
+        """
         async for event in consumer.consume_all():
             if isinstance(event, Message):
                 self._message = event
@@ -53,20 +95,60 @@ async def consume_all(
         return await self.task_manager.get_task()
 
     async def consume_and_break_on_interrupt(
-        self, consumer: EventConsumer
-    ) -> Tuple[Task | Message | None, bool]:
-        """Process the event stream until completion or an interruptable state is encountered."""
+        self,
+        consumer: EventConsumer,
+        blocking: bool = True,
+        event_callback: Callable[[Event], Awaitable[None]] | None = None,
+    ) -> tuple[Task | Message | None, bool, asyncio.Task | None]:
+        """Processes the event stream until completion or an interruptible state is encountered.
+
+        If `blocking` is False, it returns after the first event that creates a Task or Message.
+        If `blocking` is True, it waits for completion unless an `auth_required`
+        state is encountered, which is always an interruption.
+        If interrupted, consumption continues in a background task.
+
+        Args:
+            consumer: The `EventConsumer` to read events from.
+            blocking: If `False`, the method returns as soon as a task/message
+                      is available. If `True`, it waits for a terminal state.
+            event_callback: Optional async callback function to be called after each event
+                           is processed in the background continuation.
+                           Mainly used for push notifications currently.
+
+        Returns:
+            A tuple containing:
+            - The current aggregated result (`Task` or `Message`) at the point of completion or interruption.
+            - A boolean indicating whether the consumption was interrupted (`True`) or completed naturally (`False`).
+            - The background ``asyncio.Task`` that continues consuming events
+              after an interruption, or ``None`` when no background work was
+              spawned.  **Callers must hold a strong reference** to this task
+              (e.g. in a ``set``) to prevent the garbage collector from
+              collecting it before it finishes — the event loop only keeps
+              weak references to tasks.
+
+        Raises:
+            BaseException: If the `EventConsumer` raises an exception during consumption.
+        """
         event_stream = consumer.consume_all()
         interrupted = False
+        bg_task: asyncio.Task | None = None
         async for event in event_stream:
             if isinstance(event, Message):
                 self._message = event
-                return event, False
+                return event, False, None
             await self.task_manager.process(event)
-            if (
-                isinstance(event, (Task, TaskStatusUpdateEvent))
-                and event.status.state == TaskState.auth_required
-            ):
+
+            if event_callback:
+                await event_callback(event)
+
+            should_interrupt = False
+            is_auth_required = (
+                isinstance(event, Task | TaskStatusUpdateEvent)
+                and event.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+            )
+
+            # Always interrupt on auth_required, as it needs external action.
+            if is_auth_required:
                 # auth-required is a special state: the message should be
                 # escalated back to the caller, but the agent is expected to
                 # continue producing events once the authorization is received
@@ -76,22 +158,39 @@ async def consume_and_break_on_interrupt(
                 logger.debug(
                     'Encountered an auth-required task: breaking synchronous message/send flow.'
                 )
-                # TODO: We should track all outstanding tasks to ensure they eventually complete.
-                asyncio.create_task(self._continue_consuming(event_stream))
+                should_interrupt = True
+            # For non-blocking calls, interrupt as soon as a task is available.
+            elif not blocking:
+                logger.debug(
+                    'Non-blocking call: returning task after first event.'
+                )
+                should_interrupt = True
+
+            if should_interrupt:
+                # Continue consuming the rest of the events in the background.
+                # The caller is responsible for tracking this task to prevent GC.
+                bg_task = asyncio.create_task(
+                    self._continue_consuming(event_stream, event_callback)
+                )
                 interrupted = True
                 break
-        return await self.task_manager.get_task(), interrupted
+        return await self.task_manager.get_task(), interrupted, bg_task
 
-    async def _continue_consuming(self, event_stream: AsyncIterator[Event]):
+    async def _continue_consuming(
+        self,
+        event_stream: AsyncIterator[Event],
+        event_callback: Callable[[Event], Awaitable[None]] | None = None,
+    ) -> None:
+        """Continues processing an event stream in a background task.
+
+        Used after an interruptible state (like auth_required) is encountered
+        in the synchronous consumption flow.
+
+        Args:
+            event_stream: The remaining `AsyncIterator` of events from the consumer.
+            event_callback: Optional async callback function to be called after each event is processed.
+        """
         async for event in event_stream:
             await self.task_manager.process(event)
-
-    # async def consume_and_emit_task(
-    #     self, consumer: EventConsumer
-    # ) -> AsyncGenerator[Event, None]:
-    #     """Processes the event stream and emits the current state of the task."""
-    #     async for event in consumer.consume_all():
-    #         if isinstance(event, Message):
-    #             self._current_task_or_message = event
-    #             break
-    #         yield await self.task_manager.process(event)
+            if event_callback:
+                await event_callback(event)
diff --git a/src/a2a/server/tasks/task_manager.py b/src/a2a/server/tasks/task_manager.py
index a9978bce9..78722e570 100644
--- a/src/a2a/server/tasks/task_manager.py
+++ b/src/a2a/server/tasks/task_manager.py
@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import logging
 
-from a2a.server.events.event_queue import Event
-from a2a.server.tasks.task_store import TaskStore
-from a2a.types import (
-    InvalidParamsError,
+from typing import TYPE_CHECKING
+
+from a2a.plugins.types import TaskEventInfo
+from a2a.types.a2a_pb2 import (
+    Artifact,
     Message,
     Task,
     TaskArtifactUpdateEvent,
@@ -11,35 +14,185 @@
     TaskStatus,
     TaskStatusUpdateEvent,
 )
-from a2a.utils import append_artifact_to_task
-from a2a.utils.errors import ServerError
+from a2a.utils.errors import InvalidAgentResponseError, InvalidParamsError
+from a2a.utils.telemetry import trace_function
+
+
+if TYPE_CHECKING:
+    from a2a.plugins.manager import PluginManager
+    from a2a.server.cluster.task_store import VersionedTaskStore
+    from a2a.server.cluster.version import TaskVersion
+    from a2a.server.context import ServerCallContext
+    from a2a.server.events.event_queue import Event
+    from a2a.server.tasks.task_store import TaskStore
 
 
 logger = logging.getLogger(__name__)
 
 
+@trace_function()
+def append_artifact_to_task(task: Task, event: TaskArtifactUpdateEvent) -> None:
+    """Helper method for updating a Task object with new artifact data from an event.
+
+    Handles creating the artifacts list if it doesn't exist, adding new artifacts,
+    and appending parts to existing artifacts based on the `append` flag in the event.
+
+    Args:
+        task: The `Task` object to modify.
+        event: The `TaskArtifactUpdateEvent` containing the artifact data.
+    """
+    new_artifact_data: Artifact = event.artifact
+    artifact_id: str = new_artifact_data.artifact_id
+    append_parts: bool = event.append
+
+    existing_artifact: Artifact | None = None
+    existing_artifact_list_index: int | None = None
+
+    # Find existing artifact by its id
+    for i, art in enumerate(task.artifacts):
+        if art.artifact_id == artifact_id:
+            existing_artifact = art
+            existing_artifact_list_index = i
+            break
+
+    if not append_parts:
+        # This represents the first chunk for this artifact index.
+        if existing_artifact_list_index is not None:
+            # Replace the existing artifact entirely with the new data
+            logger.debug(
+                'Replacing artifact at id %s for task %s', artifact_id, task.id
+            )
+            task.artifacts[existing_artifact_list_index].CopyFrom(
+                new_artifact_data
+            )
+        else:
+            # Append the new artifact since no artifact with this index exists yet
+            logger.debug(
+                'Adding new artifact with id %s for task %s',
+                artifact_id,
+                task.id,
+            )
+            task.artifacts.append(new_artifact_data)
+    elif existing_artifact:
+        # Append new parts to the existing artifact's part list
+        logger.debug(
+            'Appending parts to artifact id %s for task %s',
+            artifact_id,
+            task.id,
+        )
+        existing_artifact.parts.extend(new_artifact_data.parts)
+        existing_artifact.metadata.update(
+            dict(new_artifact_data.metadata.items())
+        )
+    else:
+        # A2A spec (Section 4.2.2 TaskArtifactUpdateEvent,
+        # https://a2a-protocol.org/v1.0.0/specification/#422-taskartifactupdateevent):
+        #   "append — If true, the content of this artifact should be
+        #    appended to a previously sent artifact."
+        # append=True with no prior artifact of this ID is an agent
+        # protocol violation (#1038).
+        raise InvalidAgentResponseError(
+            f'append=True for nonexistent artifact_id={artifact_id!r} '
+            f'in task {task.id!r}. The artifact must be created (append=False) '
+            f'before appending parts to it.'
+        )
+
+
 class TaskManager:
-    """Helps manage a task's lifecycle during execution of a request."""
+    """Helps manage a task's lifecycle during execution of a request.
 
-    def __init__(
+    Responsible for retrieving, saving, and updating the `Task` object based on
+    events received from the agent.
+    """
+
+    def __init__(  # noqa: PLR0913
         self,
+        task_store: TaskStore | VersionedTaskStore,
+        context: ServerCallContext,
         task_id: str | None,
         context_id: str | None,
-        task_store: TaskStore,
         initial_message: Message | None,
+        plugins: PluginManager | None = None,
     ):
+        """Initializes the TaskManager.
+
+        Args:
+            task_store: The `TaskStore` (or `VersionedTaskStore`) for
+                persistence.
+            context: The `ServerCallContext` that this task is produced under.
+            task_id: The ID of the task, if known from the request.
+            context_id: The ID of the context, if known from the request.
+            initial_message: The `Message` that initiated the task, if any.
+                             Used when creating a new task object.
+            plugins: Plugin manager notified of every successful task write
+                via `on_task_event`. ``None`` disables the notifications.
+        """
+        if task_id is not None and not (isinstance(task_id, str) and task_id):
+            raise ValueError('Task ID must be a non-empty string')
+
+        # Imported lazily to avoid an import cycle: the cluster package imports
+        # from a2a.server.tasks, which imports this module.
+        from a2a.server.cluster.task_store import (  # noqa: PLC0415
+            LegacyTaskStoreAdapter,
+            VersionedTaskStore,
+        )
+        from a2a.server.cluster.version import TaskVersion  # noqa: PLC0415
+
+        self.task_store = task_store
+        self._versioned_store: VersionedTaskStore = (
+            task_store
+            if isinstance(task_store, VersionedTaskStore)
+            else LegacyTaskStoreAdapter(task_store)
+        )
+        self._call_context: ServerCallContext = context
         self.task_id = task_id
         self.context_id = context_id
-        self.task_store = task_store
         self._initial_message = initial_message
         self._current_task: Task | None = None
+        # Version of `_current_task` as last read/written. MISSING until a
+        # versioned store reports a real version.
+        self._current_version: TaskVersion = TaskVersion.MISSING
+        # Transient: the event currently being persisted, read by _save_task.
+        self._pending_event: Event | None = None
+        self._plugins = (
+            plugins if plugins is not None and plugins.has_task_hooks else None
+        )
+        # State of the task as last read from or written to the store, None
+        # if it is not known to exist. Tracked separately because writes
+        # mutate `_current_task` in place before saving it.
+        self._persisted_state: TaskState | None = None
         logger.debug(
             'TaskManager initialized with task_id: %s, context_id: %s',
             task_id,
             context_id,
         )
 
+    def invalidate(self) -> None:
+        """Drops the cached snapshot so the next read hits the store.
+
+        Only safe at a request boundary; used to pick up state another replica
+        may have advanced.
+        """
+        from a2a.server.cluster.version import TaskVersion  # noqa: PLC0415
+
+        self._current_task = None
+        self._current_version = TaskVersion.MISSING
+        self._persisted_state = None
+
+    @property
+    def current_version(self) -> TaskVersion:
+        """The version of the most recently read/written task snapshot."""
+        return self._current_version
+
     async def get_task(self) -> Task | None:
+        """Retrieves the current task object, either from memory or the store.
+
+        If `task_id` is set, it first checks the in-memory `_current_task`,
+        then attempts to load it from the `task_store`.
+
+        Returns:
+            The `Task` object if found, otherwise `None`.
+        """
         if not self.task_id:
             logger.debug('task_id is not set, cannot get task.')
             return None
@@ -50,30 +203,56 @@ async def get_task(self) -> Task | None:
         logger.debug(
             'Attempting to get task from store with id: %s', self.task_id
         )
-        self._current_task = await self.task_store.get(self.task_id)
-        if self._current_task:
+        from a2a.server.cluster.version import TaskVersion  # noqa: PLC0415
+
+        stored = await self._versioned_store.get(
+            self.task_id, self._call_context
+        )
+        if stored is not None:
+            self._current_task = stored.task
+            self._current_version = stored.version
+            self._persisted_state = stored.task.status.state
             logger.debug('Task %s retrieved successfully.', self.task_id)
         else:
+            self._current_task = None
+            self._current_version = TaskVersion.MISSING
+            self._persisted_state = None
             logger.debug('Task %s not found.', self.task_id)
         return self._current_task
 
     async def save_task_event(
         self, event: Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
     ) -> Task | None:
+        """Processes a task-related event (Task, Status, Artifact) and saves the updated task state.
+
+        Ensures task and context IDs match or are set from the event.
+
+        Args:
+            event: The task-related event (`Task`, `TaskStatusUpdateEvent`, or `TaskArtifactUpdateEvent`).
+
+        Returns:
+            The updated `Task` object after processing the event.
+
+        Raises:
+            InvalidParamsError: If the task ID in the event conflicts with the TaskManager's ID
+                         when the TaskManager's ID is already set.
+        """
         task_id_from_event = (
-            event.id if isinstance(event, Task) else event.taskId
+            event.id if isinstance(event, Task) else event.task_id
         )
         # If task id is known, make sure it is matched
         if self.task_id and self.task_id != task_id_from_event:
-            raise ServerError(
-                error=InvalidParamsError(
-                    message=f"Task in event doesn't match TaskManager {self.task_id} : {task_id_from_event}"
-                )
+            raise InvalidParamsError(
+                message=f"Task in event doesn't match TaskManager {self.task_id} : {task_id_from_event}"
             )
         if not self.task_id:
             self.task_id = task_id_from_event
-        if not self.context_id and self.context_id != event.contextId:
-            self.context_id = event.contextId
+        if self.context_id and self.context_id != event.context_id:
+            raise InvalidParamsError(
+                message=f"Context in event doesn't match TaskManager {self.context_id} : {event.context_id}"
+            )
+        if not self.context_id:
+            self.context_id = event.context_id
 
         logger.debug(
             'Processing save of task event of type %s for task_id: %s',
@@ -81,56 +260,105 @@ async def save_task_event(
             task_id_from_event,
         )
         if isinstance(event, Task):
-            await self._save_task(event)
+            self._pending_event = event
+            try:
+                await self._save_task(event)
+            finally:
+                self._pending_event = None
             return event
 
-        task: Task = await self.ensure_task(event)
+        # Apply the event to a copy; _save_task caches it only once the store
+        # accepts it. If the save raises, the cached task still matches the
+        # store, so the failure path does not take an unsaved terminal state
+        # for a saved one, and `prev` is the task as last read.
+        task = Task()
+        task.CopyFrom(await self.ensure_task(event))
 
         if isinstance(event, TaskStatusUpdateEvent):
             logger.debug(
                 'Updating task %s status to: %s', task.id, event.status.state
             )
-            if task.status.message:
-                if not task.history:
-                    task.history = [task.status.message]
-                else:
-                    task.history.append(task.status.message)
-
-            task.status = event.status
+            if task.status.HasField('message'):
+                task.history.append(task.status.message)
+            if event.metadata:
+                task.metadata.MergeFrom(event.metadata)
+            task.status.CopyFrom(event.status)
         else:
             logger.debug('Appending artifact to task %s', task.id)
             append_artifact_to_task(task, event)
 
-        await self._save_task(task)
+        self._pending_event = event
+        try:
+            await self._save_task(task)
+        finally:
+            self._pending_event = None
         return task
 
-    async def ensure_task(
-        self, event: TaskStatusUpdateEvent | TaskArtifactUpdateEvent
-    ) -> Task:
+    async def ensure_task_id(self, task_id: str, context_id: str) -> Task:
+        """Ensures a Task object exists in memory, loading from store or creating new if needed.
+
+        Args:
+            task_id: The ID for the new task.
+            context_id: The context ID for the new task.
+
+        Returns:
+            An existing or newly created `Task` object.
+        """
+        from a2a.server.cluster.version import TaskVersion  # noqa: PLC0415
+
         task: Task | None = self._current_task
         if not task and self.task_id:
             logger.debug(
                 'Attempting to retrieve existing task with id: %s', self.task_id
             )
-            task = await self.task_store.get(self.task_id)
+            stored = await self._versioned_store.get(
+                self.task_id, self._call_context
+            )
+            if stored is not None:
+                task = stored.task
+                self._current_version = stored.version
+                self._persisted_state = stored.task.status.state
+            else:
+                self._current_version = TaskVersion.MISSING
+                self._persisted_state = None
 
         if not task:
             logger.info(
                 'Task not found or task_id not set. Creating new task for event (task_id: %s, context_id: %s).',
-                event.taskId,
-                event.contextId,
+                task_id,
+                context_id,
             )
             # streaming agent did not previously stream task object.
             # Create a task object with the available information and persist the event
-            task = self._init_task_obj(event.taskId, event.contextId)
+            task = self._init_task_obj(task_id, context_id)
             await self._save_task(task)
 
         return task
 
+    async def ensure_task(
+        self, event: TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+    ) -> Task:
+        """Ensures a Task object exists in memory, loading from store or creating new if needed.
+
+        Args:
+            event: The task-related event triggering the need for a Task object.
+
+        Returns:
+            An existing or newly created `Task` object.
+        """
+        return await self.ensure_task_id(event.task_id, event.context_id)
+
     async def process(self, event: Event) -> Event:
-        """Processes an event, store the task state and return the task or message.
+        """Processes an event, updates the task state if applicable, stores it, and returns the event.
 
-        The returned Task or Message represent the current status of the result.
+        If the event is task-related (`Task`, `TaskStatusUpdateEvent`, `TaskArtifactUpdateEvent`),
+        the internal task state is updated and persisted.
+
+        Args:
+            event: The event object received from the agent.
+
+        Returns:
+            The same event object that was processed.
         """
         if isinstance(
             event, Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
@@ -140,7 +368,15 @@ async def process(self, event: Event) -> Event:
         return event
 
     def _init_task_obj(self, task_id: str, context_id: str) -> Task:
-        """Initializes a new task object."""
+        """Initializes a new task object in memory.
+
+        Args:
+            task_id: The ID for the new task.
+            context_id: The context ID for the new task.
+
+        Returns:
+            A new `Task` object with initial status and potentially the initial message in history.
+        """
         logger.debug(
             'Initializing new Task object with task_id: %s, context_id: %s',
             task_id,
@@ -149,35 +385,61 @@ def _init_task_obj(self, task_id: str, context_id: str) -> Task:
         history = [self._initial_message] if self._initial_message else []
         return Task(
             id=task_id,
-            contextId=context_id,
-            status=TaskStatus(state=TaskState.submitted),
+            context_id=context_id,
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
             history=history,
         )
 
     async def _save_task(self, task: Task) -> None:
+        """Saves the task and updates the snapshot.
+
+        Threads `_current_version` so a VersionedTaskStore can compare-and-swap;
+        raises ConcurrentTaskModificationError on a stale write.
+        """
         logger.debug('Saving task with id: %s', task.id)
-        await self.task_store.save(task)
+        prev = self._current_task
+        self._current_version = await self._versioned_store.save(
+            task,
+            event=self._pending_event,
+            prev=prev,
+            prev_version=self._current_version,
+            context=self._call_context,
+        )
         self._current_task = task
         if not self.task_id:
             logger.info('New task created with id: %s', task.id)
             self.task_id = task.id
-            self.context_id = task.contextId
+            self.context_id = task.context_id
+        from_state = self._persisted_state
+        self._persisted_state = task.status.state
+        if self._plugins is not None:
+            await self._plugins.on_task_event(
+                TaskEventInfo(
+                    task_id=task.id,
+                    from_state=from_state,
+                    to_state=task.status.state,
+                    event=self._pending_event,
+                    task=task,
+                    context=self._call_context,
+                )
+            )
 
     def update_with_message(self, message: Message, task: Task) -> Task:
-        """Update the prior status to history, and add the incoming message to history.
+        """Updates a task object in memory by adding a new message to its history.
 
-        This updates the object in memory, and the _current_task, but does not
-        persist it. This is the job of the processor after this step.
+        If the task has a message in its current status, that message is moved
+        to the history first.
+
+        Args:
+            message: The new `Message` to add to the history.
+            task: The `Task` object to update.
+
+        Returns:
+            The updated `Task` object (updated in-place).
         """
-        if task.status.message:
-            if task.history:
-                task.history.append(task.status.message)
-            else:
-                task.history = [task.status.message]
-            task.status.message = None
-        if task.history:
-            task.history.append(message)
-        else:
-            task.history = [message]
+        if task.status.HasField('message'):
+            task.history.append(task.status.message)
+            task.status.ClearField('message')
+        task.history.append(message)
         self._current_task = task
         return task
diff --git a/src/a2a/server/tasks/task_store.py b/src/a2a/server/tasks/task_store.py
index af856d6f2..25e4838d1 100644
--- a/src/a2a/server/tasks/task_store.py
+++ b/src/a2a/server/tasks/task_store.py
@@ -1,19 +1,33 @@
 from abc import ABC, abstractmethod
 
-from a2a.types import Task
+from a2a.server.context import ServerCallContext
+from a2a.types.a2a_pb2 import ListTasksRequest, ListTasksResponse, Task
 
 
 class TaskStore(ABC):
-    """Agent Task Store interface."""
+    """Agent Task Store interface.
+
+    Defines the methods for persisting and retrieving `Task` objects.
+    """
+
+    @abstractmethod
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        """Saves or updates a task in the store."""
 
     @abstractmethod
-    async def save(self, task: Task):
-        pass
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> Task | None:
+        """Retrieves a task from the store by ID."""
 
     @abstractmethod
-    async def get(self, task_id: str) -> Task | None:
-        pass
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Retrieves a list of tasks from the store."""
 
     @abstractmethod
-    async def delete(self, task_id: str):
-        pass
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task from the store by ID."""
diff --git a/src/a2a/server/tasks/task_updater.py b/src/a2a/server/tasks/task_updater.py
index 39751c92f..83b47780b 100644
--- a/src/a2a/server/tasks/task_updater.py
+++ b/src/a2a/server/tasks/task_updater.py
@@ -1,7 +1,17 @@
-import uuid
+import asyncio
+
+from datetime import datetime, timezone
+from typing import Any
+
+from google.protobuf.timestamp_pb2 import Timestamp
 
 from a2a.server.events import EventQueue
-from a2a.types import (
+from a2a.server.id_generator import (
+    IDGenerator,
+    IDGeneratorContext,
+    UUIDGenerator,
+)
+from a2a.types.a2a_pb2 import (
     Artifact,
     Message,
     Part,
@@ -11,83 +21,215 @@
     TaskStatus,
     TaskStatusUpdateEvent,
 )
+from a2a.utils.constants import TERMINAL_TASK_STATES
 
 
 class TaskUpdater:
-    """Helper class for publishing updates to a task."""
+    """Helper class for agents to publish updates to a task's event queue.
+
+    Simplifies the process of creating and enqueueing standard task events.
+    """
+
+    def __init__(
+        self,
+        event_queue: EventQueue,
+        task_id: str,
+        context_id: str,
+        artifact_id_generator: IDGenerator | None = None,
+        message_id_generator: IDGenerator | None = None,
+    ):
+        """Initializes the TaskUpdater.
 
-    def __init__(self, event_queue: EventQueue, task_id: str, context_id: str):
+        Args:
+            event_queue: The `EventQueue` associated with the task.
+            task_id: The ID of the task.
+            context_id: The context ID of the task.
+            artifact_id_generator: ID generator for new artifact IDs. Defaults to UUID generator.
+            message_id_generator: ID generator for new message IDs. Defaults to UUID generator.
+        """
         self.event_queue = event_queue
         self.task_id = task_id
         self.context_id = context_id
+        self._lock = asyncio.Lock()
+        self._terminal_state_reached = False
+        self._terminal_states = set(TERMINAL_TASK_STATES)
+        self._artifact_id_generator = (
+            artifact_id_generator if artifact_id_generator else UUIDGenerator()
+        )
+        self._message_id_generator = (
+            message_id_generator if message_id_generator else UUIDGenerator()
+        )
 
-    def update_status(
-        self, state: TaskState, message: Message | None = None, final=False
-    ):
-        """Update the status of the task."""
-        self.event_queue.enqueue_event(
-            TaskStatusUpdateEvent(
-                taskId=self.task_id,
-                contextId=self.context_id,
-                final=final,
-                status=TaskStatus(
-                    state=state,
-                    message=message,
-                ),
+    async def update_status(
+        self,
+        state: TaskState,
+        message: Message | None = None,
+        timestamp: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Updates the status of the task and publishes a `TaskStatusUpdateEvent`.
+
+        Args:
+            state: The new state of the task.
+            message: An optional message associated with the status update.
+            timestamp: Optional ISO 8601 datetime string. Defaults to current time.
+            metadata: Optional metadata for extensions.
+        """
+        async with self._lock:
+            if self._terminal_state_reached:
+                raise RuntimeError(
+                    f'Task {self.task_id} is already in a terminal state.'
+                )
+
+            # Create proto timestamp from datetime
+            ts = Timestamp()
+            if timestamp:
+                # If timestamp string provided, parse it
+                dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                ts.FromDatetime(dt)
+            else:
+                ts.FromDatetime(datetime.now(timezone.utc))
+
+            status = TaskStatus(state=state)
+            if message:
+                status.message.CopyFrom(message)
+            status.timestamp.CopyFrom(ts)
+
+            event = TaskStatusUpdateEvent(
+                task_id=self.task_id,
+                context_id=self.context_id,
+                metadata=metadata,
+                status=status,
             )
-        )
+            if state in self._terminal_states:
+                self._terminal_state_reached = True
+            await self.event_queue.enqueue_event(event)
 
-    def add_artifact(
+    async def add_artifact(  # noqa: PLR0913
         self,
         parts: list[Part],
-        artifact_id=str(uuid.uuid4()),
+        artifact_id: str | None = None,
         name: str | None = None,
-    ):
-        """Add an artifact to the task."""
-        self.event_queue.enqueue_event(
+        metadata: dict[str, Any] | None = None,
+        append: bool | None = None,
+        last_chunk: bool | None = None,
+        extensions: list[str] | None = None,
+    ) -> None:
+        """Adds an artifact chunk to the task and publishes a `TaskArtifactUpdateEvent`.
+
+        Args:
+            parts: A list of `Part` objects forming the artifact chunk.
+            artifact_id: The ID of the artifact. A new UUID is generated if not provided.
+            name: Optional name for the artifact.
+            metadata: Optional metadata for the artifact.
+            append: Optional boolean indicating if this chunk appends to a previous one.
+            last_chunk: Optional boolean indicating if this is the last chunk.
+            extensions: Optional list of extensions for the artifact.
+        """
+        if not artifact_id:
+            artifact_id = self._artifact_id_generator.generate(
+                IDGeneratorContext(
+                    task_id=self.task_id, context_id=self.context_id
+                )
+            )
+
+        await self.event_queue.enqueue_event(
             TaskArtifactUpdateEvent(
-                taskId=self.task_id,
-                contextId=self.context_id,
+                task_id=self.task_id,
+                context_id=self.context_id,
                 artifact=Artifact(
-                    artifactId=artifact_id,
+                    artifact_id=artifact_id,
                     name=name,
                     parts=parts,
+                    metadata=metadata,
+                    extensions=extensions,
                 ),
+                append=append,
+                last_chunk=last_chunk,
             )
         )
 
-    def complete(self, message: Message | None = None):
-        """Mark the task as completed."""
-        self.update_status(
-            TaskState.completed,
+    async def complete(self, message: Message | None = None) -> None:
+        """Marks the task as completed and publishes a final status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_COMPLETED,
+            message=message,
+        )
+
+    async def failed(self, message: Message | None = None) -> None:
+        """Marks the task as failed and publishes a final status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_FAILED,
+            message=message,
+        )
+
+    async def reject(self, message: Message | None = None) -> None:
+        """Marks the task as rejected and publishes a final status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_REJECTED,
+            message=message,
+        )
+
+    async def submit(self, message: Message | None = None) -> None:
+        """Marks the task as submitted and publishes a status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_SUBMITTED,
             message=message,
-            final=True,
         )
 
-    def submit(self, message: Message | None = None):
-        """Mark the task as submitted."""
-        self.update_status(
-            TaskState.submitted,
+    async def start_work(self, message: Message | None = None) -> None:
+        """Marks the task as working and publishes a status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_WORKING,
             message=message,
         )
 
-    def start_work(self, message: Message | None = None):
-        """Mark the task as working."""
-        self.update_status(
-            TaskState.working,
+    async def cancel(self, message: Message | None = None) -> None:
+        """Marks the task as cancelled and publishes a finalstatus update."""
+        await self.update_status(
+            TaskState.TASK_STATE_CANCELED,
             message=message,
         )
 
+    async def requires_input(self, message: Message | None = None) -> None:
+        """Marks the task as input required and publishes a status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_INPUT_REQUIRED,
+            message=message,
+        )
+
+    async def requires_auth(self, message: Message | None = None) -> None:
+        """Marks the task as auth required and publishes a status update."""
+        await self.update_status(
+            TaskState.TASK_STATE_AUTH_REQUIRED, message=message
+        )
+
     def new_agent_message(
-        self, parts: list[Part], final=False, metadata=None
+        self,
+        parts: list[Part],
+        metadata: dict[str, Any] | None = None,
     ) -> Message:
-        """Create a new message for the task."""
+        """Creates a new message object sent by the agent for this task/context.
+
+        Note: This method only *creates* the message object. It does not
+              automatically enqueue it.
+
+        Args:
+            parts: A list of `Part` objects for the message content.
+            metadata: Optional metadata for the message.
+
+        Returns:
+            A new `Message` object.
+        """
         return Message(
-            role=Role.agent,
-            taskId=self.task_id,
-            contextId=self.context_id,
-            messageId=str(uuid.uuid4()),
+            role=Role.ROLE_AGENT,
+            task_id=self.task_id,
+            context_id=self.context_id,
+            message_id=self._message_id_generator.generate(
+                IDGeneratorContext(
+                    task_id=self.task_id, context_id=self.context_id
+                )
+            ),
             metadata=metadata,
-            final=final,
             parts=parts,
         )
diff --git a/src/a2a/types.py b/src/a2a/types.py
deleted file mode 100644
index e7dc4c915..000000000
--- a/src/a2a/types.py
+++ /dev/null
@@ -1,1360 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  spec.json
-
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Literal
-
-from pydantic import BaseModel, RootModel
-
-
-class A2A(RootModel[Any]):
-    root: Any
-
-
-class AgentAuthentication(BaseModel):
-    """
-    Defines authentication requirements for an agent.
-    Intended to match OpenAPI authentication structure.
-    """
-
-    credentials: str | None = None
-    """
-    credentials a client should use for private cards
-    """
-    schemes: list[str]
-    """
-    e.g. Basic, Bearer
-    """
-
-
-class AgentCapabilities(BaseModel):
-    """
-    Defines optional capabilities supported by an agent.
-    """
-
-    pushNotifications: bool | None = None
-    """
-    true if the agent can notify updates to client
-    """
-    stateTransitionHistory: bool | None = None
-    """
-    true if the agent exposes status change history for tasks
-    """
-    streaming: bool | None = None
-    """
-    true if the agent supports SSE
-    """
-
-
-class AgentProvider(BaseModel):
-    """
-    Represents the service provider of an agent.
-    """
-
-    organization: str
-    """
-    Agent provider's organization name
-    """
-    url: str
-    """
-    Agent provider's url
-    """
-
-
-class AgentSkill(BaseModel):
-    """
-    Represents a unit of capability that an agent can perform.
-    """
-
-    description: str
-    """
-    description of the skill - will be used by the client or a human
-    as a hint to understand what the skill does.
-    """
-    examples: list[str] | None = None
-    """
-    The set of example scenarios that the skill can perform.
-    Will be used by the client as a hint to understand how the skill can be
-    used.
-    """
-    id: str
-    """
-    unique identifier for the agent's skill
-    """
-    inputModes: list[str] | None = None
-    """
-    The set of interaction modes that the skill supports
-    (if different than the default).
-    Supported mime types for input.
-    """
-    name: str
-    """
-    human readable name of the skill
-    """
-    outputModes: list[str] | None = None
-    """
-    Supported mime types for output.
-    """
-    tags: list[str]
-    """
-    Set of tagwords describing classes of capabilities for this specific
-    skill.
-    """
-
-
-class ContentTypeNotSupportedError(BaseModel):
-    """
-    A2A specific error indicating incompatible content types between request and agent capabilities.
-    """
-
-    code: Literal[-32005] = -32005
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Incompatible content types'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class DataPart(BaseModel):
-    """
-    Represents a structured data segment within a message part.
-    """
-
-    data: dict[str, Any]
-    """
-    Structured data content
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    Optional metadata associated with the part.
-    """
-    type: Literal['data'] = 'data'
-    """
-    Part type - data for DataParts
-    """
-
-
-class FileBase(BaseModel):
-    """
-    Represents the base entity for FileParts
-    """
-
-    mimeType: str | None = None
-    """
-    Optional mimeType for the file
-    """
-    name: str | None = None
-    """
-    Optional name for the file
-    """
-
-
-class FileWithBytes(BaseModel):
-    """
-    Define the variant where 'bytes' is present and 'uri' is absent
-    """
-
-    bytes: str
-    """
-    base64 encoded content of the file
-    """
-    mimeType: str | None = None
-    """
-    Optional mimeType for the file
-    """
-    name: str | None = None
-    """
-    Optional name for the file
-    """
-
-
-class FileWithUri(BaseModel):
-    """
-    Define the variant where 'uri' is present and 'bytes' is absent
-    """
-
-    mimeType: str | None = None
-    """
-    Optional mimeType for the file
-    """
-    name: str | None = None
-    """
-    Optional name for the file
-    """
-    uri: str
-
-
-class InternalError(BaseModel):
-    """
-    JSON-RPC error indicating an internal JSON-RPC error on the server.
-    """
-
-    code: Literal[-32603] = -32603
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Internal error'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class InvalidAgentResponseError(BaseModel):
-    """
-    A2A specific error indicating agent returned invalid response for the current method
-    """
-
-    code: Literal[-32006] = -32006
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Invalid agent response'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class InvalidParamsError(BaseModel):
-    """
-    JSON-RPC error indicating invalid method parameter(s).
-    """
-
-    code: Literal[-32602] = -32602
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Invalid parameters'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class InvalidRequestError(BaseModel):
-    """
-    JSON-RPC error indicating the JSON sent is not a valid Request object.
-    """
-
-    code: Literal[-32600] = -32600
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Request payload validation error'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class JSONParseError(BaseModel):
-    """
-    JSON-RPC error indicating invalid JSON was received by the server.
-    """
-
-    code: Literal[-32700] = -32700
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Invalid JSON payload'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class JSONRPCError(BaseModel):
-    """
-    Represents a JSON-RPC 2.0 Error object.
-    This is typically included in a JSONRPCErrorResponse when an error occurs.
-    """
-
-    code: int
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str
-    """
-    A String providing a short description of the error.
-    """
-
-
-class JSONRPCMessage(BaseModel):
-    """
-    Base interface for any JSON-RPC 2.0 request or response.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-
-
-class JSONRPCRequest(BaseModel):
-    """
-    Represents a JSON-RPC 2.0 Request object.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: str
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: dict[str, Any] | None = None
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class JSONRPCResult(BaseModel):
-    """
-    Represents a JSON-RPC 2.0 Result object.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: Any
-    """
-    The result object on success
-    """
-
-
-class Role(Enum):
-    """
-    message sender's role
-    """
-
-    agent = 'agent'
-    user = 'user'
-
-
-class MethodNotFoundError(BaseModel):
-    """
-    JSON-RPC error indicating the method does not exist or is not available.
-    """
-
-    code: Literal[-32601] = -32601
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Method not found'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class PartBase(BaseModel):
-    """
-    Base properties common to all message parts.
-    """
-
-    metadata: dict[str, Any] | None = None
-    """
-    Optional metadata associated with the part.
-    """
-
-
-class PushNotificationAuthenticationInfo(BaseModel):
-    """
-    Defines authentication details for push notifications.
-    """
-
-    credentials: str | None = None
-    """
-    Optional credentials
-    """
-    schemes: list[str]
-    """
-    Supported authentication schemes - e.g. Basic, Bearer
-    """
-
-
-class PushNotificationConfig(BaseModel):
-    """
-    Configuration for setting up push notifications for task updates.
-    """
-
-    authentication: PushNotificationAuthenticationInfo | None = None
-    token: str | None = None
-    """
-    token unique to this task/session
-    """
-    url: str
-    """
-    url for sending the push notifications
-    """
-
-
-class PushNotificationNotSupportedError(BaseModel):
-    """
-    A2A specific error indicating the agent does not support push notifications.
-    """
-
-    code: Literal[-32003] = -32003
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Push Notification is not supported'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class TaskIdParams(BaseModel):
-    """
-    Parameters containing only a task ID, used for simple task operations.
-    """
-
-    id: str
-    """
-    task id
-    """
-    metadata: dict[str, Any] | None = None
-
-
-class TaskNotCancelableError(BaseModel):
-    """
-    A2A specific error indicating the task is in a state where it cannot be canceled.
-    """
-
-    code: Literal[-32002] = -32002
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Task cannot be canceled'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class TaskNotFoundError(BaseModel):
-    """
-    A2A specific error indicating the requested task ID was not found.
-    """
-
-    code: Literal[-32001] = -32001
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'Task not found'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class TaskPushNotificationConfig(BaseModel):
-    """
-    Parameters for setting or getting push notification configuration for a task
-    """
-
-    pushNotificationConfig: PushNotificationConfig
-    taskId: str
-    """
-    task id
-    """
-
-
-class TaskQueryParams(BaseModel):
-    """
-    Parameters for querying a task, including optional history length.
-    """
-
-    historyLength: int | None = None
-    """
-    number of recent messages to be retrieved
-    """
-    id: str
-    """
-    task id
-    """
-    metadata: dict[str, Any] | None = None
-
-
-class TaskResubscriptionRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'tasks/resubscribe' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['tasks/resubscribe'] = 'tasks/resubscribe'
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: TaskIdParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class TaskState(Enum):
-    """
-    Represents the possible states of a Task.
-    """
-
-    submitted = 'submitted'
-    working = 'working'
-    input_required = 'input-required'
-    auth_required = 'auth-required'
-    completed = 'completed'
-    canceled = 'canceled'
-    failed = 'failed'
-    rejected = 'rejected'
-    unknown = 'unknown'
-
-
-class TextPart(BaseModel):
-    """
-    Represents a text segment within parts.
-    """
-
-    metadata: dict[str, Any] | None = None
-    """
-    Optional metadata associated with the part.
-    """
-    text: str
-    """
-    Text content
-    """
-    type: Literal['text'] = 'text'
-    """
-    Part type - text for TextParts
-    """
-
-
-class UnsupportedOperationError(BaseModel):
-    """
-    A2A specific error indicating the requested operation is not supported by the agent.
-    """
-
-    code: Literal[-32004] = -32004
-    """
-    A Number that indicates the error type that occurred.
-    """
-    data: Any | None = None
-    """
-    A Primitive or Structured value that contains additional information about the error.
-    This may be omitted.
-    """
-    message: str | None = 'This operation is not supported'
-    """
-    A String providing a short description of the error.
-    """
-
-
-class A2AError(
-    RootModel[
-        JSONParseError
-        | InvalidRequestError
-        | MethodNotFoundError
-        | InvalidParamsError
-        | InternalError
-        | TaskNotFoundError
-        | TaskNotCancelableError
-        | PushNotificationNotSupportedError
-        | UnsupportedOperationError
-        | ContentTypeNotSupportedError
-        | InvalidAgentResponseError
-    ]
-):
-    root: (
-        JSONParseError
-        | InvalidRequestError
-        | MethodNotFoundError
-        | InvalidParamsError
-        | InternalError
-        | TaskNotFoundError
-        | TaskNotCancelableError
-        | PushNotificationNotSupportedError
-        | UnsupportedOperationError
-        | ContentTypeNotSupportedError
-        | InvalidAgentResponseError
-    )
-
-
-class AgentCard(BaseModel):
-    """
-    An AgentCard conveys key information:
-    - Overall details (version, name, description, uses)
-    - Skills: A set of capabilities the agent can perform
-    - Default modalities/content types supported by the agent.
-    - Authentication requirements
-    """
-
-    authentication: AgentAuthentication
-    """
-    Authentication requirements for the agent.
-    """
-    capabilities: AgentCapabilities
-    """
-    Optional capabilities supported by the agent.
-    """
-    defaultInputModes: list[str]
-    """
-    The set of interaction modes that the agent
-    supports across all skills. This can be overridden per-skill.
-    Supported mime types for input.
-    """
-    defaultOutputModes: list[str]
-    """
-    Supported mime types for output.
-    """
-    description: str
-    """
-    A human-readable description of the agent. Used to assist users and
-    other agents in understanding what the agent can do.
-    """
-    documentationUrl: str | None = None
-    """
-    A URL to documentation for the agent.
-    """
-    name: str
-    """
-    Human readable name of the agent.
-    """
-    provider: AgentProvider | None = None
-    """
-    The service provider of the agent
-    """
-    skills: list[AgentSkill]
-    """
-    Skills are a unit of capability that an agent can perform.
-    """
-    url: str
-    """
-    A URL to the address the agent is hosted at.
-    """
-    version: str
-    """
-    The version of the agent - format is up to the provider.
-    """
-
-
-class CancelTaskRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'tasks/cancel' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['tasks/cancel'] = 'tasks/cancel'
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: TaskIdParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class FilePart(BaseModel):
-    """
-    Represents a File segment within parts.
-    """
-
-    file: FileWithBytes | FileWithUri
-    """
-    File content either as url or bytes
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    Optional metadata associated with the part.
-    """
-    type: Literal['file'] = 'file'
-    """
-    Part type - file for FileParts
-    """
-
-
-class GetTaskPushNotificationConfigRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'tasks/pushNotificationConfig/get' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['tasks/pushNotificationConfig/get'] = (
-        'tasks/pushNotificationConfig/get'
-    )
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: TaskIdParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class GetTaskPushNotificationConfigSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response model for the 'tasks/pushNotificationConfig/get' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: TaskPushNotificationConfig
-    """
-    The result object on success
-    """
-
-
-class GetTaskRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'tasks/get' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['tasks/get'] = 'tasks/get'
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: TaskQueryParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class JSONRPCErrorResponse(BaseModel):
-    """
-    Represents a JSON-RPC 2.0 Error Response object.
-    """
-
-    error: (
-        JSONRPCError
-        | JSONParseError
-        | InvalidRequestError
-        | MethodNotFoundError
-        | InvalidParamsError
-        | InternalError
-        | TaskNotFoundError
-        | TaskNotCancelableError
-        | PushNotificationNotSupportedError
-        | UnsupportedOperationError
-        | ContentTypeNotSupportedError
-        | InvalidAgentResponseError
-    )
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-
-
-class MessageSendConfiguration(BaseModel):
-    """
-    Configuration for the send message request
-    """
-
-    acceptedOutputModes: list[str]
-    """
-    accepted output modalities by the client
-    """
-    blocking: bool | None = None
-    """
-    If the server should treat the client as a blocking request
-    """
-    historyLength: int | None = None
-    """
-    number of recent messages to be retrieved
-    """
-    pushNotificationConfig: PushNotificationConfig | None = None
-    """
-    where the server should send notifications when disconnected.
-    """
-
-
-class Part(RootModel[TextPart | FilePart | DataPart]):
-    root: TextPart | FilePart | DataPart
-    """
-    Represents a part of a message, which can be text, a file, or structured data.
-    """
-
-
-class SetTaskPushNotificationConfigRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'tasks/pushNotificationConfig/set' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['tasks/pushNotificationConfig/set'] = (
-        'tasks/pushNotificationConfig/set'
-    )
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: TaskPushNotificationConfig
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class SetTaskPushNotificationConfigSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response model for the 'tasks/pushNotificationConfig/set' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: TaskPushNotificationConfig
-    """
-    The result object on success
-    """
-
-
-class Artifact(BaseModel):
-    """
-    Represents an artifact generated for a task.
-    """
-
-    artifactId: str
-    """
-    unique identifier for the artifact
-    """
-    description: str | None = None
-    """
-    Optional description for the artifact
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-    name: str | None = None
-    """
-    Optional name for the artifact
-    """
-    parts: list[Part]
-    """
-    artifact parts
-    """
-
-
-class GetTaskPushNotificationConfigResponse(
-    RootModel[
-        JSONRPCErrorResponse | GetTaskPushNotificationConfigSuccessResponse
-    ]
-):
-    root: JSONRPCErrorResponse | GetTaskPushNotificationConfigSuccessResponse
-    """
-    JSON-RPC response for the 'tasks/pushNotificationConfig/set' method.
-    """
-
-
-class Message(BaseModel):
-    """
-    Represents a single message exchanged between user and agent.
-    """
-
-    contextId: str | None = None
-    """
-    the context the message is associated with
-    """
-    final: bool | None = None
-    """
-    indicates the end of the event stream
-    """
-    messageId: str
-    """
-    identifier created by the message creator
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-    parts: list[Part]
-    """
-    message content
-    """
-    role: Role
-    """
-    message sender's role
-    """
-    taskId: str | None = None
-    """
-    identifier of task the message is related to
-    """
-    type: Literal['message'] = 'message'
-    """
-    event type
-    """
-
-
-class MessageSendParams(BaseModel):
-    """
-    Sent by the client to the agent as a request. May create, continue or restart a task.
-    """
-
-    configuration: MessageSendConfiguration | None = None
-    """
-    Send message configuration
-    """
-    message: Message
-    """
-    The message being sent to the server
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-
-
-class SendMessageRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'message/send' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['message/send'] = 'message/send'
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: MessageSendParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class SendStreamingMessageRequest(BaseModel):
-    """
-    JSON-RPC request model for the 'message/stream' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    method: Literal['message/stream'] = 'message/stream'
-    """
-    A String containing the name of the method to be invoked.
-    """
-    params: MessageSendParams
-    """
-    A Structured value that holds the parameter values to be used during the invocation of the method.
-    """
-
-
-class SetTaskPushNotificationConfigResponse(
-    RootModel[
-        JSONRPCErrorResponse | SetTaskPushNotificationConfigSuccessResponse
-    ]
-):
-    root: JSONRPCErrorResponse | SetTaskPushNotificationConfigSuccessResponse
-    """
-    JSON-RPC response for the 'tasks/pushNotificationConfig/set' method.
-    """
-
-
-class TaskArtifactUpdateEvent(BaseModel):
-    """
-    sent by server during sendStream or subscribe requests
-    """
-
-    append: bool | None = None
-    """
-    Indicates if this artifact appends to a previous one
-    """
-    artifact: Artifact
-    """
-    generated artifact
-    """
-    contextId: str
-    """
-    the context the task is associated with
-    """
-    lastChunk: bool | None = None
-    """
-    Indicates if this is the last chunk of the artifact
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-    taskId: str
-    """
-    Task id
-    """
-    type: Literal['artifact-update'] = 'artifact-update'
-    """
-    event type
-    """
-
-
-class TaskStatus(BaseModel):
-    """
-    TaskState and accompanying message.
-    """
-
-    message: Message | None = None
-    """
-    additional status updates for client
-    """
-    state: TaskState
-    timestamp: str | None = None
-    """
-    ISO 8601 datetime string when the status was recorded.
-    """
-
-
-class TaskStatusUpdateEvent(BaseModel):
-    """
-    sent by server during sendStream or subscribe requests
-    """
-
-    contextId: str
-    """
-    the context the task is associated with
-    """
-    final: bool
-    """
-    indicates the end of the event stream
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-    status: TaskStatus
-    """
-    current status of the task
-    """
-    taskId: str
-    """
-    Task id
-    """
-    type: Literal['status-update'] = 'status-update'
-    """
-    event type
-    """
-
-
-class A2ARequest(
-    RootModel[
-        SendMessageRequest
-        | SendStreamingMessageRequest
-        | GetTaskRequest
-        | CancelTaskRequest
-        | SetTaskPushNotificationConfigRequest
-        | GetTaskPushNotificationConfigRequest
-        | TaskResubscriptionRequest
-    ]
-):
-    root: (
-        SendMessageRequest
-        | SendStreamingMessageRequest
-        | GetTaskRequest
-        | CancelTaskRequest
-        | SetTaskPushNotificationConfigRequest
-        | GetTaskPushNotificationConfigRequest
-        | TaskResubscriptionRequest
-    )
-    """
-    A2A supported request types
-    """
-
-
-class Task(BaseModel):
-    artifacts: list[Artifact] | None = None
-    """
-    collection of artifacts created by the agent.
-    """
-    contextId: str
-    """
-    server-generated id for contextual alignment across interactions
-    """
-    history: list[Message] | None = None
-    id: str
-    """
-    unique identifier for the task
-    """
-    metadata: dict[str, Any] | None = None
-    """
-    extension metadata
-    """
-    status: TaskStatus
-    """
-    current status of the task
-    """
-    type: Literal['task'] = 'task'
-    """
-    event type
-    """
-
-
-class CancelTaskSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response model for the 'tasks/cancel' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: Task
-    """
-    The result object on success
-    """
-
-
-class GetTaskSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response for the 'tasks/get' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: Task
-    """
-    The result object on success
-    """
-
-
-class SendMessageSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response model for the 'message/send' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: Task | Message
-    """
-    The result object on success
-    """
-
-
-class SendStreamingMessageSuccessResponse(BaseModel):
-    """
-    JSON-RPC success response model for the 'message/stream' method.
-    """
-
-    id: str | int | None = None
-    """
-    An identifier established by the Client that MUST contain a String, Number
-    Numbers SHOULD NOT contain fractional parts.
-    """
-    jsonrpc: Literal['2.0'] = '2.0'
-    """
-    Specifies the version of the JSON-RPC protocol. MUST be exactly "2.0".
-    """
-    result: Task | Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
-    """
-    The result object on success
-    """
-
-
-class CancelTaskResponse(
-    RootModel[JSONRPCErrorResponse | CancelTaskSuccessResponse]
-):
-    root: JSONRPCErrorResponse | CancelTaskSuccessResponse
-    """
-    JSON-RPC response for the 'tasks/cancel' method.
-    """
-
-
-class GetTaskResponse(RootModel[JSONRPCErrorResponse | GetTaskSuccessResponse]):
-    root: JSONRPCErrorResponse | GetTaskSuccessResponse
-    """
-    JSON-RPC success response for the 'tasks/get' method.
-    """
-
-
-class JSONRPCResponse(
-    RootModel[
-        JSONRPCErrorResponse
-        | SendMessageSuccessResponse
-        | SendStreamingMessageSuccessResponse
-        | GetTaskSuccessResponse
-        | CancelTaskSuccessResponse
-        | SetTaskPushNotificationConfigSuccessResponse
-        | GetTaskPushNotificationConfigSuccessResponse
-    ]
-):
-    root: (
-        JSONRPCErrorResponse
-        | SendMessageSuccessResponse
-        | SendStreamingMessageSuccessResponse
-        | GetTaskSuccessResponse
-        | CancelTaskSuccessResponse
-        | SetTaskPushNotificationConfigSuccessResponse
-        | GetTaskPushNotificationConfigSuccessResponse
-    )
-    """
-    Represents a JSON-RPC 2.0 Response object.
-    """
-
-
-class SendMessageResponse(
-    RootModel[JSONRPCErrorResponse | SendMessageSuccessResponse]
-):
-    root: JSONRPCErrorResponse | SendMessageSuccessResponse
-    """
-    JSON-RPC response model for the 'message/send' method.
-    """
-
-
-class SendStreamingMessageResponse(
-    RootModel[JSONRPCErrorResponse | SendStreamingMessageSuccessResponse]
-):
-    root: JSONRPCErrorResponse | SendStreamingMessageSuccessResponse
-    """
-    JSON-RPC response model for the 'message/stream' method.
-    """
diff --git a/src/a2a/types/__init__.py b/src/a2a/types/__init__.py
new file mode 100644
index 000000000..1f54c8ad7
--- /dev/null
+++ b/src/a2a/types/__init__.py
@@ -0,0 +1,146 @@
+"""A2A Types Package - Protocol Buffer and SDK-specific types."""
+
+# Import all proto-generated types from a2a_pb2
+from a2a.types.a2a_pb2 import (
+    APIKeySecurityScheme,
+    AgentCapabilities,
+    AgentCard,
+    AgentCardSignature,
+    AgentExtension,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+    Artifact,
+    AuthenticationInfo,
+    AuthorizationCodeOAuthFlow,
+    CancelTaskRequest,
+    ClientCredentialsOAuthFlow,
+    DeleteTaskPushNotificationConfigRequest,
+    DeviceCodeOAuthFlow,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    HTTPAuthSecurityScheme,
+    ImplicitOAuthFlow,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    MutualTlsSecurityScheme,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    OpenIdConnectSecurityScheme,
+    Part,
+    PasswordOAuthFlow,
+    Role,
+    SecurityRequirement,
+    SecurityScheme,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    StringList,
+    SubscribeToTaskRequest,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+# Import SDK-specific error types from utils.errors
+from a2a.utils.errors import (
+    ContentTypeNotSupportedError,
+    ExtendedAgentCardNotConfiguredError,
+    ExtensionSupportRequiredError,
+    InternalError,
+    InvalidAgentResponseError,
+    InvalidParamsError,
+    InvalidRequestError,
+    MethodNotFoundError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+    VersionNotSupportedError,
+)
+
+
+A2ARequest = (
+    SendMessageRequest
+    | GetTaskRequest
+    | CancelTaskRequest
+    | TaskPushNotificationConfig
+    | GetTaskPushNotificationConfigRequest
+    | SubscribeToTaskRequest
+    | GetExtendedAgentCardRequest
+    | ListTaskPushNotificationConfigsRequest
+)
+
+
+__all__ = [
+    # SDK-specific types from extras
+    'A2ARequest',
+    # Proto types
+    'APIKeySecurityScheme',
+    'AgentCapabilities',
+    'AgentCard',
+    'AgentCardSignature',
+    'AgentExtension',
+    'AgentInterface',
+    'AgentProvider',
+    'AgentSkill',
+    'Artifact',
+    'AuthenticationInfo',
+    'AuthorizationCodeOAuthFlow',
+    'CancelTaskRequest',
+    'ClientCredentialsOAuthFlow',
+    'ContentTypeNotSupportedError',
+    'DeleteTaskPushNotificationConfigRequest',
+    'DeviceCodeOAuthFlow',
+    'ExtendedAgentCardNotConfiguredError',
+    'ExtensionSupportRequiredError',
+    'GetExtendedAgentCardRequest',
+    'GetTaskPushNotificationConfigRequest',
+    'GetTaskRequest',
+    'HTTPAuthSecurityScheme',
+    'ImplicitOAuthFlow',
+    'InternalError',
+    'InvalidAgentResponseError',
+    'InvalidParamsError',
+    'InvalidRequestError',
+    'ListTaskPushNotificationConfigsRequest',
+    'ListTaskPushNotificationConfigsResponse',
+    'ListTasksRequest',
+    'ListTasksResponse',
+    'Message',
+    'MethodNotFoundError',
+    'MutualTlsSecurityScheme',
+    'OAuth2SecurityScheme',
+    'OAuthFlows',
+    'OpenIdConnectSecurityScheme',
+    'Part',
+    'PasswordOAuthFlow',
+    'PushNotificationNotSupportedError',
+    'Role',
+    'SecurityRequirement',
+    'SecurityScheme',
+    'SendMessageConfiguration',
+    'SendMessageRequest',
+    'SendMessageResponse',
+    'StreamResponse',
+    'StringList',
+    'SubscribeToTaskRequest',
+    'Task',
+    'TaskArtifactUpdateEvent',
+    'TaskNotCancelableError',
+    'TaskNotFoundError',
+    'TaskPushNotificationConfig',
+    'TaskState',
+    'TaskStatus',
+    'TaskStatusUpdateEvent',
+    'UnsupportedOperationError',
+    'VersionNotSupportedError',
+]
diff --git a/src/a2a/types/a2a_pb2.py b/src/a2a/types/a2a_pb2.py
new file mode 100644
index 000000000..a47abe4a3
--- /dev/null
+++ b/src/a2a/types/a2a_pb2.py
@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: a2a.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'a2a.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2
+from google.api import client_pb2 as google_dot_api_dot_client__pb2
+from google.api import field_behavior_pb2 as google_dot_api_dot_field__behavior__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ta2a.proto\x12\tlf.a2a.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa6\x02\n\x18SendMessageConfiguration\x12\x32\n\x15\x61\x63\x63\x65pted_output_modes\x18\x01 \x03(\tR\x13\x61\x63\x63\x65ptedOutputModes\x12h\n\x1dtask_push_notification_config\x18\x02 \x01(\x0b\x32%.lf.a2a.v1.TaskPushNotificationConfigR\x1ataskPushNotificationConfig\x12*\n\x0ehistory_length\x18\x03 \x01(\x05H\x00R\rhistoryLength\x88\x01\x01\x12-\n\x12return_immediately\x18\x04 \x01(\x08R\x11returnImmediatelyB\x11\n\x0f_history_length\"\x84\x02\n\x04Task\x12\x13\n\x02id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x02id\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12\x32\n\x06status\x18\x03 \x01(\x0b\x32\x15.lf.a2a.v1.TaskStatusB\x03\xe0\x41\x02R\x06status\x12\x31\n\tartifacts\x18\x04 \x03(\x0b\x32\x13.lf.a2a.v1.ArtifactR\tartifacts\x12,\n\x07history\x18\x05 \x03(\x0b\x32\x12.lf.a2a.v1.MessageR\x07history\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"\xa5\x01\n\nTaskStatus\x12/\n\x05state\x18\x01 \x01(\x0e\x32\x14.lf.a2a.v1.TaskStateB\x03\xe0\x41\x02R\x05state\x12,\n\x07message\x18\x02 \x01(\x0b\x32\x12.lf.a2a.v1.MessageR\x07message\x12\x38\n\ttimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\"\xed\x01\n\x04Part\x12\x14\n\x04text\x18\x01 \x01(\tH\x00R\x04text\x12\x12\n\x03raw\x18\x02 \x01(\x0cH\x00R\x03raw\x12\x12\n\x03url\x18\x03 \x01(\tH\x00R\x03url\x12,\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x16.google.protobuf.ValueH\x00R\x04\x64\x61ta\x12\x33\n\x08metadata\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12\x1a\n\x08\x66ilename\x18\x06 \x01(\tR\x08\x66ilename\x12\x1d\n\nmedia_type\x18\x07 \x01(\tR\tmediaTypeB\t\n\x07\x63ontent\"\xbe\x02\n\x07Message\x12\"\n\nmessage_id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\tmessageId\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12\x17\n\x07task_id\x18\x03 \x01(\tR\x06taskId\x12(\n\x04role\x18\x04 \x01(\x0e\x32\x0f.lf.a2a.v1.RoleB\x03\xe0\x41\x02R\x04role\x12*\n\x05parts\x18\x05 \x03(\x0b\x32\x0f.lf.a2a.v1.PartB\x03\xe0\x41\x02R\x05parts\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12\x1e\n\nextensions\x18\x07 \x03(\tR\nextensions\x12,\n\x12reference_task_ids\x18\x08 \x03(\tR\x10referenceTaskIds\"\xe7\x01\n\x08\x41rtifact\x12$\n\x0b\x61rtifact_id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\nartifactId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x03 \x01(\tR\x0b\x64\x65scription\x12*\n\x05parts\x18\x04 \x03(\x0b\x32\x0f.lf.a2a.v1.PartB\x03\xe0\x41\x02R\x05parts\x12\x33\n\x08metadata\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12\x1e\n\nextensions\x18\x06 \x03(\tR\nextensions\"\xc2\x01\n\x15TaskStatusUpdateEvent\x12\x1c\n\x07task_id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x06taskId\x12\"\n\ncontext_id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\tcontextId\x12\x32\n\x06status\x18\x03 \x01(\x0b\x32\x15.lf.a2a.v1.TaskStatusB\x03\xe0\x41\x02R\x06status\x12\x33\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"\xfd\x01\n\x17TaskArtifactUpdateEvent\x12\x1c\n\x07task_id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x06taskId\x12\"\n\ncontext_id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\tcontextId\x12\x34\n\x08\x61rtifact\x18\x03 \x01(\x0b\x32\x13.lf.a2a.v1.ArtifactB\x03\xe0\x41\x02R\x08\x61rtifact\x12\x16\n\x06\x61ppend\x18\x04 \x01(\x08R\x06\x61ppend\x12\x1d\n\nlast_chunk\x18\x05 \x01(\x08R\tlastChunk\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"S\n\x12\x41uthenticationInfo\x12\x1b\n\x06scheme\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x06scheme\x12 \n\x0b\x63redentials\x18\x02 \x01(\tR\x0b\x63redentials\"\x9f\x01\n\x0e\x41gentInterface\x12\x15\n\x03url\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x03url\x12.\n\x10protocol_binding\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x0fprotocolBinding\x12\x16\n\x06tenant\x18\x03 \x01(\tR\x06tenant\x12.\n\x10protocol_version\x18\x04 \x01(\tB\x03\xe0\x41\x02R\x0fprotocolVersion\"\x98\x07\n\tAgentCard\x12\x17\n\x04name\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x04name\x12%\n\x0b\x64\x65scription\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x0b\x64\x65scription\x12Q\n\x14supported_interfaces\x18\x03 \x03(\x0b\x32\x19.lf.a2a.v1.AgentInterfaceB\x03\xe0\x41\x02R\x13supportedInterfaces\x12\x34\n\x08provider\x18\x04 \x01(\x0b\x32\x18.lf.a2a.v1.AgentProviderR\x08provider\x12\x1d\n\x07version\x18\x05 \x01(\tB\x03\xe0\x41\x02R\x07version\x12\x30\n\x11\x64ocumentation_url\x18\x06 \x01(\tH\x00R\x10\x64ocumentationUrl\x88\x01\x01\x12\x45\n\x0c\x63\x61pabilities\x18\x07 \x01(\x0b\x32\x1c.lf.a2a.v1.AgentCapabilitiesB\x03\xe0\x41\x02R\x0c\x63\x61pabilities\x12T\n\x10security_schemes\x18\x08 \x03(\x0b\x32).lf.a2a.v1.AgentCard.SecuritySchemesEntryR\x0fsecuritySchemes\x12S\n\x15security_requirements\x18\t \x03(\x0b\x32\x1e.lf.a2a.v1.SecurityRequirementR\x14securityRequirements\x12\x33\n\x13\x64\x65\x66\x61ult_input_modes\x18\n \x03(\tB\x03\xe0\x41\x02R\x11\x64\x65\x66\x61ultInputModes\x12\x35\n\x14\x64\x65\x66\x61ult_output_modes\x18\x0b \x03(\tB\x03\xe0\x41\x02R\x12\x64\x65\x66\x61ultOutputModes\x12\x32\n\x06skills\x18\x0c \x03(\x0b\x32\x15.lf.a2a.v1.AgentSkillB\x03\xe0\x41\x02R\x06skills\x12=\n\nsignatures\x18\r \x03(\x0b\x32\x1d.lf.a2a.v1.AgentCardSignatureR\nsignatures\x12\x1e\n\x08icon_url\x18\x0e \x01(\tH\x01R\x07iconUrl\x88\x01\x01\x1a]\n\x14SecuritySchemesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12/\n\x05value\x18\x02 \x01(\x0b\x32\x19.lf.a2a.v1.SecuritySchemeR\x05value:\x02\x38\x01\x42\x14\n\x12_documentation_urlB\x0b\n\t_icon_url\"O\n\rAgentProvider\x12\x15\n\x03url\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x03url\x12\'\n\x0corganization\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x0corganization\"\x97\x02\n\x11\x41gentCapabilities\x12!\n\tstreaming\x18\x01 \x01(\x08H\x00R\tstreaming\x88\x01\x01\x12\x32\n\x12push_notifications\x18\x02 \x01(\x08H\x01R\x11pushNotifications\x88\x01\x01\x12\x39\n\nextensions\x18\x03 \x03(\x0b\x32\x19.lf.a2a.v1.AgentExtensionR\nextensions\x12\x33\n\x13\x65xtended_agent_card\x18\x04 \x01(\x08H\x02R\x11\x65xtendedAgentCard\x88\x01\x01\x42\x0c\n\n_streamingB\x15\n\x13_push_notificationsB\x16\n\x14_extended_agent_card\"\x91\x01\n\x0e\x41gentExtension\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x1a\n\x08required\x18\x03 \x01(\x08R\x08required\x12/\n\x06params\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\x06params\"\xaf\x02\n\nAgentSkill\x12\x13\n\x02id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x02id\x12\x17\n\x04name\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x04name\x12%\n\x0b\x64\x65scription\x18\x03 \x01(\tB\x03\xe0\x41\x02R\x0b\x64\x65scription\x12\x17\n\x04tags\x18\x04 \x03(\tB\x03\xe0\x41\x02R\x04tags\x12\x1a\n\x08\x65xamples\x18\x05 \x03(\tR\x08\x65xamples\x12\x1f\n\x0binput_modes\x18\x06 \x03(\tR\ninputModes\x12!\n\x0coutput_modes\x18\x07 \x03(\tR\x0boutputModes\x12S\n\x15security_requirements\x18\x08 \x03(\x0b\x32\x1e.lf.a2a.v1.SecurityRequirementR\x14securityRequirements\"\x8b\x01\n\x12\x41gentCardSignature\x12!\n\tprotected\x18\x01 \x01(\tB\x03\xe0\x41\x02R\tprotected\x12!\n\tsignature\x18\x02 \x01(\tB\x03\xe0\x41\x02R\tsignature\x12/\n\x06header\x18\x03 \x01(\x0b\x32\x17.google.protobuf.StructR\x06header\"\xd1\x01\n\x1aTaskPushNotificationConfig\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x0e\n\x02id\x18\x02 \x01(\tR\x02id\x12\x17\n\x07task_id\x18\x03 \x01(\tR\x06taskId\x12\x15\n\x03url\x18\x04 \x01(\tB\x03\xe0\x41\x02R\x03url\x12\x14\n\x05token\x18\x05 \x01(\tR\x05token\x12\x45\n\x0e\x61uthentication\x18\x06 \x01(\x0b\x32\x1d.lf.a2a.v1.AuthenticationInfoR\x0e\x61uthentication\" \n\nStringList\x12\x12\n\x04list\x18\x01 \x03(\tR\x04list\"\xaf\x01\n\x13SecurityRequirement\x12\x45\n\x07schemes\x18\x01 \x03(\x0b\x32+.lf.a2a.v1.SecurityRequirement.SchemesEntryR\x07schemes\x1aQ\n\x0cSchemesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12+\n\x05value\x18\x02 \x01(\x0b\x32\x15.lf.a2a.v1.StringListR\x05value:\x02\x38\x01\"\xf5\x03\n\x0eSecurityScheme\x12X\n\x17\x61pi_key_security_scheme\x18\x01 \x01(\x0b\x32\x1f.lf.a2a.v1.APIKeySecuritySchemeH\x00R\x14\x61piKeySecurityScheme\x12^\n\x19http_auth_security_scheme\x18\x02 \x01(\x0b\x32!.lf.a2a.v1.HTTPAuthSecuritySchemeH\x00R\x16httpAuthSecurityScheme\x12W\n\x16oauth2_security_scheme\x18\x03 \x01(\x0b\x32\x1f.lf.a2a.v1.OAuth2SecuritySchemeH\x00R\x14oauth2SecurityScheme\x12n\n\x1fopen_id_connect_security_scheme\x18\x04 \x01(\x0b\x32&.lf.a2a.v1.OpenIdConnectSecuritySchemeH\x00R\x1bopenIdConnectSecurityScheme\x12V\n\x14mtls_security_scheme\x18\x05 \x01(\x0b\x32\".lf.a2a.v1.MutualTlsSecuritySchemeH\x00R\x12mtlsSecuritySchemeB\x08\n\x06scheme\"r\n\x14\x41PIKeySecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x1f\n\x08location\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x08location\x12\x17\n\x04name\x18\x03 \x01(\tB\x03\xe0\x41\x02R\x04name\"|\n\x16HTTPAuthSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x1b\n\x06scheme\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x06scheme\x12#\n\rbearer_format\x18\x03 \x01(\tR\x0c\x62\x65\x61rerFormat\"\x9a\x01\n\x14OAuth2SecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x30\n\x05\x66lows\x18\x02 \x01(\x0b\x32\x15.lf.a2a.v1.OAuthFlowsB\x03\xe0\x41\x02R\x05\x66lows\x12.\n\x13oauth2_metadata_url\x18\x03 \x01(\tR\x11oauth2MetadataUrl\"s\n\x1bOpenIdConnectSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x32\n\x13open_id_connect_url\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x10openIdConnectUrl\";\n\x17MutualTlsSecurityScheme\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\"\x87\x03\n\nOAuthFlows\x12V\n\x12\x61uthorization_code\x18\x01 \x01(\x0b\x32%.lf.a2a.v1.AuthorizationCodeOAuthFlowH\x00R\x11\x61uthorizationCode\x12V\n\x12\x63lient_credentials\x18\x02 \x01(\x0b\x32%.lf.a2a.v1.ClientCredentialsOAuthFlowH\x00R\x11\x63lientCredentials\x12>\n\x08implicit\x18\x03 \x01(\x0b\x32\x1c.lf.a2a.v1.ImplicitOAuthFlowB\x02\x18\x01H\x00R\x08implicit\x12>\n\x08password\x18\x04 \x01(\x0b\x32\x1c.lf.a2a.v1.PasswordOAuthFlowB\x02\x18\x01H\x00R\x08password\x12\x41\n\x0b\x64\x65vice_code\x18\x05 \x01(\x0b\x32\x1e.lf.a2a.v1.DeviceCodeOAuthFlowH\x00R\ndeviceCodeB\x06\n\x04\x66low\"\xc1\x02\n\x1a\x41uthorizationCodeOAuthFlow\x12\x30\n\x11\x61uthorization_url\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x10\x61uthorizationUrl\x12 \n\ttoken_url\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x03 \x01(\tR\nrefreshUrl\x12N\n\x06scopes\x18\x04 \x03(\x0b\x32\x31.lf.a2a.v1.AuthorizationCodeOAuthFlow.ScopesEntryB\x03\xe0\x41\x02R\x06scopes\x12#\n\rpkce_required\x18\x05 \x01(\x08R\x0cpkceRequired\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xea\x01\n\x1a\x43lientCredentialsOAuthFlow\x12 \n\ttoken_url\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12N\n\x06scopes\x18\x03 \x03(\x0b\x32\x31.lf.a2a.v1.ClientCredentialsOAuthFlow.ScopesEntryB\x03\xe0\x41\x02R\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xde\x01\n\x11ImplicitOAuthFlow\x12+\n\x11\x61uthorization_url\x18\x01 \x01(\tR\x10\x61uthorizationUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12@\n\x06scopes\x18\x03 \x03(\x0b\x32(.lf.a2a.v1.ImplicitOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xce\x01\n\x11PasswordOAuthFlow\x12\x1b\n\ttoken_url\x18\x01 \x01(\tR\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x02 \x01(\tR\nrefreshUrl\x12@\n\x06scopes\x18\x03 \x03(\x0b\x32(.lf.a2a.v1.PasswordOAuthFlow.ScopesEntryR\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x9b\x02\n\x13\x44\x65viceCodeOAuthFlow\x12=\n\x18\x64\x65vice_authorization_url\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x16\x64\x65viceAuthorizationUrl\x12 \n\ttoken_url\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x08tokenUrl\x12\x1f\n\x0brefresh_url\x18\x03 \x01(\tR\nrefreshUrl\x12G\n\x06scopes\x18\x04 \x03(\x0b\x32*.lf.a2a.v1.DeviceCodeOAuthFlow.ScopesEntryB\x03\xe0\x41\x02R\x06scopes\x1a\x39\n\x0bScopesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xdf\x01\n\x12SendMessageRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x31\n\x07message\x18\x02 \x01(\x0b\x32\x12.lf.a2a.v1.MessageB\x03\xe0\x41\x02R\x07message\x12I\n\rconfiguration\x18\x03 \x01(\x0b\x32#.lf.a2a.v1.SendMessageConfigurationR\rconfiguration\x12\x33\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"|\n\x0eGetTaskRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x13\n\x02id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x02id\x12*\n\x0ehistory_length\x18\x03 \x01(\x05H\x00R\rhistoryLength\x88\x01\x01\x42\x11\n\x0f_history_length\"\x9f\x03\n\x10ListTasksRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x1d\n\ncontext_id\x18\x02 \x01(\tR\tcontextId\x12,\n\x06status\x18\x03 \x01(\x0e\x32\x14.lf.a2a.v1.TaskStateR\x06status\x12 \n\tpage_size\x18\x04 \x01(\x05H\x00R\x08pageSize\x88\x01\x01\x12\x1d\n\npage_token\x18\x05 \x01(\tR\tpageToken\x12*\n\x0ehistory_length\x18\x06 \x01(\x05H\x01R\rhistoryLength\x88\x01\x01\x12P\n\x16status_timestamp_after\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x14statusTimestampAfter\x12\x30\n\x11include_artifacts\x18\x08 \x01(\x08H\x02R\x10includeArtifacts\x88\x01\x01\x42\x0c\n\n_page_sizeB\x11\n\x0f_history_lengthB\x14\n\x12_include_artifacts\"\xb2\x01\n\x11ListTasksResponse\x12*\n\x05tasks\x18\x01 \x03(\x0b\x32\x0f.lf.a2a.v1.TaskB\x03\xe0\x41\x02R\x05tasks\x12+\n\x0fnext_page_token\x18\x02 \x01(\tB\x03\xe0\x41\x02R\rnextPageToken\x12 \n\tpage_size\x18\x03 \x01(\x05\x42\x03\xe0\x41\x02R\x08pageSize\x12\"\n\ntotal_size\x18\x04 \x01(\x05\x42\x03\xe0\x41\x02R\ttotalSize\"u\n\x11\x43\x61ncelTaskRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x13\n\x02id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x02id\x12\x33\n\x08metadata\x18\x03 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\"q\n$GetTaskPushNotificationConfigRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x1c\n\x07task_id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x06taskId\x12\x13\n\x02id\x18\x03 \x01(\tB\x03\xe0\x41\x02R\x02id\"t\n\'DeleteTaskPushNotificationConfigRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x1c\n\x07task_id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x06taskId\x12\x13\n\x02id\x18\x03 \x01(\tB\x03\xe0\x41\x02R\x02id\"E\n\x16SubscribeToTaskRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\x12\x13\n\x02id\x18\x02 \x01(\tB\x03\xe0\x41\x02R\x02id\"\x9a\x01\n&ListTaskPushNotificationConfigsRequest\x12\x16\n\x06tenant\x18\x04 \x01(\tR\x06tenant\x12\x1c\n\x07task_id\x18\x01 \x01(\tB\x03\xe0\x41\x02R\x06taskId\x12\x1b\n\tpage_size\x18\x02 \x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x03 \x01(\tR\tpageToken\"5\n\x1bGetExtendedAgentCardRequest\x12\x16\n\x06tenant\x18\x01 \x01(\tR\x06tenant\"w\n\x13SendMessageResponse\x12%\n\x04task\x18\x01 \x01(\x0b\x32\x0f.lf.a2a.v1.TaskH\x00R\x04task\x12.\n\x07message\x18\x02 \x01(\x0b\x32\x12.lf.a2a.v1.MessageH\x00R\x07messageB\t\n\x07payload\"\x8a\x02\n\x0eStreamResponse\x12%\n\x04task\x18\x01 \x01(\x0b\x32\x0f.lf.a2a.v1.TaskH\x00R\x04task\x12.\n\x07message\x18\x02 \x01(\x0b\x32\x12.lf.a2a.v1.MessageH\x00R\x07message\x12G\n\rstatus_update\x18\x03 \x01(\x0b\x32 .lf.a2a.v1.TaskStatusUpdateEventH\x00R\x0cstatusUpdate\x12M\n\x0f\x61rtifact_update\x18\x04 \x01(\x0b\x32\".lf.a2a.v1.TaskArtifactUpdateEventH\x00R\x0e\x61rtifactUpdateB\t\n\x07payload\"\x92\x01\n\'ListTaskPushNotificationConfigsResponse\x12?\n\x07\x63onfigs\x18\x01 \x03(\x0b\x32%.lf.a2a.v1.TaskPushNotificationConfigR\x07\x63onfigs\x12&\n\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken*\xf9\x01\n\tTaskState\x12\x1a\n\x16TASK_STATE_UNSPECIFIED\x10\x00\x12\x18\n\x14TASK_STATE_SUBMITTED\x10\x01\x12\x16\n\x12TASK_STATE_WORKING\x10\x02\x12\x18\n\x14TASK_STATE_COMPLETED\x10\x03\x12\x15\n\x11TASK_STATE_FAILED\x10\x04\x12\x17\n\x13TASK_STATE_CANCELED\x10\x05\x12\x1d\n\x19TASK_STATE_INPUT_REQUIRED\x10\x06\x12\x17\n\x13TASK_STATE_REJECTED\x10\x07\x12\x1c\n\x18TASK_STATE_AUTH_REQUIRED\x10\x08*;\n\x04Role\x12\x14\n\x10ROLE_UNSPECIFIED\x10\x00\x12\r\n\tROLE_USER\x10\x01\x12\x0e\n\nROLE_AGENT\x10\x02\x32\x97\x0f\n\nA2AService\x12\x83\x01\n\x0bSendMessage\x12\x1d.lf.a2a.v1.SendMessageRequest\x1a\x1e.lf.a2a.v1.SendMessageResponse\"5\x82\xd3\xe4\x93\x02/\"\r/message:send:\x01*Z\x1b\"\x16/{tenant}/message:send:\x01*\x12\x8d\x01\n\x14SendStreamingMessage\x12\x1d.lf.a2a.v1.SendMessageRequest\x1a\x19.lf.a2a.v1.StreamResponse\"9\x82\xd3\xe4\x93\x02\x33\"\x0f/message:stream:\x01*Z\x1d\"\x18/{tenant}/message:stream:\x01*0\x01\x12k\n\x07GetTask\x12\x19.lf.a2a.v1.GetTaskRequest\x1a\x0f.lf.a2a.v1.Task\"4\xda\x41\x02id\x82\xd3\xe4\x93\x02)\x12\r/tasks/{id=*}Z\x18\x12\x16/{tenant}/tasks/{id=*}\x12i\n\tListTasks\x12\x1b.lf.a2a.v1.ListTasksRequest\x1a\x1c.lf.a2a.v1.ListTasksResponse\"!\x82\xd3\xe4\x93\x02\x1b\x12\x06/tasksZ\x11\x12\x0f/{tenant}/tasks\x12\x80\x01\n\nCancelTask\x12\x1c.lf.a2a.v1.CancelTaskRequest\x1a\x0f.lf.a2a.v1.Task\"C\x82\xd3\xe4\x93\x02=\"\x14/tasks/{id=*}:cancel:\x01*Z\"\"\x1d/{tenant}/tasks/{id=*}:cancel:\x01*\x12\x96\x01\n\x0fSubscribeToTask\x12!.lf.a2a.v1.SubscribeToTaskRequest\x1a\x19.lf.a2a.v1.StreamResponse\"C\x82\xd3\xe4\x93\x02=\x12\x17/tasks/{id=*}:subscribeZ\"\x12 /{tenant}/tasks/{id=*}:subscribe0\x01\x12\xf3\x01\n CreateTaskPushNotificationConfig\x12%.lf.a2a.v1.TaskPushNotificationConfig\x1a%.lf.a2a.v1.TaskPushNotificationConfig\"\x80\x01\xda\x41\x0etask_id,config\x82\xd3\xe4\x93\x02i\"*/tasks/{task_id=*}/pushNotificationConfigs:\x01*Z8\"3/{tenant}/tasks/{task_id=*}/pushNotificationConfigs:\x01*\x12\xfe\x01\n\x1dGetTaskPushNotificationConfig\x12/.lf.a2a.v1.GetTaskPushNotificationConfigRequest\x1a%.lf.a2a.v1.TaskPushNotificationConfig\"\x84\x01\xda\x41\ntask_id,id\x82\xd3\xe4\x93\x02q\x12\x31/tasks/{task_id=*}/pushNotificationConfigs/{id=*}Z<\x12:/{tenant}/tasks/{task_id=*}/pushNotificationConfigs/{id=*}\x12\xfd\x01\n\x1fListTaskPushNotificationConfigs\x12\x31.lf.a2a.v1.ListTaskPushNotificationConfigsRequest\x1a\x32.lf.a2a.v1.ListTaskPushNotificationConfigsResponse\"s\xda\x41\x07task_id\x82\xd3\xe4\x93\x02\x63\x12*/tasks/{task_id=*}/pushNotificationConfigsZ5\x12\x33/{tenant}/tasks/{task_id=*}/pushNotificationConfigs\x12\x8f\x01\n\x14GetExtendedAgentCard\x12&.lf.a2a.v1.GetExtendedAgentCardRequest\x1a\x14.lf.a2a.v1.AgentCard\"9\x82\xd3\xe4\x93\x02\x33\x12\x12/extendedAgentCardZ\x1d\x12\x1b/{tenant}/extendedAgentCard\x12\xf5\x01\n DeleteTaskPushNotificationConfig\x12\x32.lf.a2a.v1.DeleteTaskPushNotificationConfigRequest\x1a\x16.google.protobuf.Empty\"\x84\x01\xda\x41\ntask_id,id\x82\xd3\xe4\x93\x02q*1/tasks/{task_id=*}/pushNotificationConfigs/{id=*}Z<*:/{tenant}/tasks/{task_id=*}/pushNotificationConfigs/{id=*}B|\n\rcom.lf.a2a.v1B\x08\x41\x32\x61ProtoP\x01Z\x1bgoogle.golang.org/lf/a2a/v1\xa2\x02\x03LAX\xaa\x02\tLf.A2a.V1\xca\x02\tLf\\A2a\\V1\xe2\x02\x15Lf\\A2a\\V1\\GPBMetadata\xea\x02\x0bLf::A2a::V1b\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'a2a_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\rcom.lf.a2a.v1B\010A2aProtoP\001Z\033google.golang.org/lf/a2a/v1\242\002\003LAX\252\002\tLf.A2a.V1\312\002\tLf\\A2a\\V1\342\002\025Lf\\A2a\\V1\\GPBMetadata\352\002\013Lf::A2a::V1'
+  _globals['_TASK'].fields_by_name['id']._loaded_options = None
+  _globals['_TASK'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_TASK'].fields_by_name['status']._loaded_options = None
+  _globals['_TASK'].fields_by_name['status']._serialized_options = b'\340A\002'
+  _globals['_TASKSTATUS'].fields_by_name['state']._loaded_options = None
+  _globals['_TASKSTATUS'].fields_by_name['state']._serialized_options = b'\340A\002'
+  _globals['_MESSAGE'].fields_by_name['message_id']._loaded_options = None
+  _globals['_MESSAGE'].fields_by_name['message_id']._serialized_options = b'\340A\002'
+  _globals['_MESSAGE'].fields_by_name['role']._loaded_options = None
+  _globals['_MESSAGE'].fields_by_name['role']._serialized_options = b'\340A\002'
+  _globals['_MESSAGE'].fields_by_name['parts']._loaded_options = None
+  _globals['_MESSAGE'].fields_by_name['parts']._serialized_options = b'\340A\002'
+  _globals['_ARTIFACT'].fields_by_name['artifact_id']._loaded_options = None
+  _globals['_ARTIFACT'].fields_by_name['artifact_id']._serialized_options = b'\340A\002'
+  _globals['_ARTIFACT'].fields_by_name['parts']._loaded_options = None
+  _globals['_ARTIFACT'].fields_by_name['parts']._serialized_options = b'\340A\002'
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['task_id']._loaded_options = None
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['task_id']._serialized_options = b'\340A\002'
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['context_id']._loaded_options = None
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['context_id']._serialized_options = b'\340A\002'
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['status']._loaded_options = None
+  _globals['_TASKSTATUSUPDATEEVENT'].fields_by_name['status']._serialized_options = b'\340A\002'
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['task_id']._loaded_options = None
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['task_id']._serialized_options = b'\340A\002'
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['context_id']._loaded_options = None
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['context_id']._serialized_options = b'\340A\002'
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['artifact']._loaded_options = None
+  _globals['_TASKARTIFACTUPDATEEVENT'].fields_by_name['artifact']._serialized_options = b'\340A\002'
+  _globals['_AUTHENTICATIONINFO'].fields_by_name['scheme']._loaded_options = None
+  _globals['_AUTHENTICATIONINFO'].fields_by_name['scheme']._serialized_options = b'\340A\002'
+  _globals['_AGENTINTERFACE'].fields_by_name['url']._loaded_options = None
+  _globals['_AGENTINTERFACE'].fields_by_name['url']._serialized_options = b'\340A\002'
+  _globals['_AGENTINTERFACE'].fields_by_name['protocol_binding']._loaded_options = None
+  _globals['_AGENTINTERFACE'].fields_by_name['protocol_binding']._serialized_options = b'\340A\002'
+  _globals['_AGENTINTERFACE'].fields_by_name['protocol_version']._loaded_options = None
+  _globals['_AGENTINTERFACE'].fields_by_name['protocol_version']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._loaded_options = None
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_options = b'8\001'
+  _globals['_AGENTCARD'].fields_by_name['name']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['name']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['description']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['description']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['supported_interfaces']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['supported_interfaces']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['version']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['version']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['capabilities']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['capabilities']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['default_input_modes']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['default_input_modes']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['default_output_modes']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['default_output_modes']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARD'].fields_by_name['skills']._loaded_options = None
+  _globals['_AGENTCARD'].fields_by_name['skills']._serialized_options = b'\340A\002'
+  _globals['_AGENTPROVIDER'].fields_by_name['url']._loaded_options = None
+  _globals['_AGENTPROVIDER'].fields_by_name['url']._serialized_options = b'\340A\002'
+  _globals['_AGENTPROVIDER'].fields_by_name['organization']._loaded_options = None
+  _globals['_AGENTPROVIDER'].fields_by_name['organization']._serialized_options = b'\340A\002'
+  _globals['_AGENTSKILL'].fields_by_name['id']._loaded_options = None
+  _globals['_AGENTSKILL'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_AGENTSKILL'].fields_by_name['name']._loaded_options = None
+  _globals['_AGENTSKILL'].fields_by_name['name']._serialized_options = b'\340A\002'
+  _globals['_AGENTSKILL'].fields_by_name['description']._loaded_options = None
+  _globals['_AGENTSKILL'].fields_by_name['description']._serialized_options = b'\340A\002'
+  _globals['_AGENTSKILL'].fields_by_name['tags']._loaded_options = None
+  _globals['_AGENTSKILL'].fields_by_name['tags']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['protected']._loaded_options = None
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['protected']._serialized_options = b'\340A\002'
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['signature']._loaded_options = None
+  _globals['_AGENTCARDSIGNATURE'].fields_by_name['signature']._serialized_options = b'\340A\002'
+  _globals['_TASKPUSHNOTIFICATIONCONFIG'].fields_by_name['url']._loaded_options = None
+  _globals['_TASKPUSHNOTIFICATIONCONFIG'].fields_by_name['url']._serialized_options = b'\340A\002'
+  _globals['_SECURITYREQUIREMENT_SCHEMESENTRY']._loaded_options = None
+  _globals['_SECURITYREQUIREMENT_SCHEMESENTRY']._serialized_options = b'8\001'
+  _globals['_APIKEYSECURITYSCHEME'].fields_by_name['location']._loaded_options = None
+  _globals['_APIKEYSECURITYSCHEME'].fields_by_name['location']._serialized_options = b'\340A\002'
+  _globals['_APIKEYSECURITYSCHEME'].fields_by_name['name']._loaded_options = None
+  _globals['_APIKEYSECURITYSCHEME'].fields_by_name['name']._serialized_options = b'\340A\002'
+  _globals['_HTTPAUTHSECURITYSCHEME'].fields_by_name['scheme']._loaded_options = None
+  _globals['_HTTPAUTHSECURITYSCHEME'].fields_by_name['scheme']._serialized_options = b'\340A\002'
+  _globals['_OAUTH2SECURITYSCHEME'].fields_by_name['flows']._loaded_options = None
+  _globals['_OAUTH2SECURITYSCHEME'].fields_by_name['flows']._serialized_options = b'\340A\002'
+  _globals['_OPENIDCONNECTSECURITYSCHEME'].fields_by_name['open_id_connect_url']._loaded_options = None
+  _globals['_OPENIDCONNECTSECURITYSCHEME'].fields_by_name['open_id_connect_url']._serialized_options = b'\340A\002'
+  _globals['_OAUTHFLOWS'].fields_by_name['implicit']._loaded_options = None
+  _globals['_OAUTHFLOWS'].fields_by_name['implicit']._serialized_options = b'\030\001'
+  _globals['_OAUTHFLOWS'].fields_by_name['password']._loaded_options = None
+  _globals['_OAUTHFLOWS'].fields_by_name['password']._serialized_options = b'\030\001'
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['authorization_url']._loaded_options = None
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['authorization_url']._serialized_options = b'\340A\002'
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['token_url']._loaded_options = None
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['token_url']._serialized_options = b'\340A\002'
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['scopes']._loaded_options = None
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW'].fields_by_name['scopes']._serialized_options = b'\340A\002'
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW'].fields_by_name['token_url']._loaded_options = None
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW'].fields_by_name['token_url']._serialized_options = b'\340A\002'
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW'].fields_by_name['scopes']._loaded_options = None
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW'].fields_by_name['scopes']._serialized_options = b'\340A\002'
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_DEVICECODEOAUTHFLOW_SCOPESENTRY']._loaded_options = None
+  _globals['_DEVICECODEOAUTHFLOW_SCOPESENTRY']._serialized_options = b'8\001'
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['device_authorization_url']._loaded_options = None
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['device_authorization_url']._serialized_options = b'\340A\002'
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['token_url']._loaded_options = None
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['token_url']._serialized_options = b'\340A\002'
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['scopes']._loaded_options = None
+  _globals['_DEVICECODEOAUTHFLOW'].fields_by_name['scopes']._serialized_options = b'\340A\002'
+  _globals['_SENDMESSAGEREQUEST'].fields_by_name['message']._loaded_options = None
+  _globals['_SENDMESSAGEREQUEST'].fields_by_name['message']._serialized_options = b'\340A\002'
+  _globals['_GETTASKREQUEST'].fields_by_name['id']._loaded_options = None
+  _globals['_GETTASKREQUEST'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['tasks']._loaded_options = None
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['tasks']._serialized_options = b'\340A\002'
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['next_page_token']._loaded_options = None
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['next_page_token']._serialized_options = b'\340A\002'
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['page_size']._loaded_options = None
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['page_size']._serialized_options = b'\340A\002'
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['total_size']._loaded_options = None
+  _globals['_LISTTASKSRESPONSE'].fields_by_name['total_size']._serialized_options = b'\340A\002'
+  _globals['_CANCELTASKREQUEST'].fields_by_name['id']._loaded_options = None
+  _globals['_CANCELTASKREQUEST'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['task_id']._loaded_options = None
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['task_id']._serialized_options = b'\340A\002'
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['id']._loaded_options = None
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['task_id']._loaded_options = None
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['task_id']._serialized_options = b'\340A\002'
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['id']._loaded_options = None
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_SUBSCRIBETOTASKREQUEST'].fields_by_name['id']._loaded_options = None
+  _globals['_SUBSCRIBETOTASKREQUEST'].fields_by_name['id']._serialized_options = b'\340A\002'
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSREQUEST'].fields_by_name['task_id']._loaded_options = None
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSREQUEST'].fields_by_name['task_id']._serialized_options = b'\340A\002'
+  _globals['_A2ASERVICE'].methods_by_name['SendMessage']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['SendMessage']._serialized_options = b'\202\323\344\223\002/\"\r/message:send:\001*Z\033\"\026/{tenant}/message:send:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['SendStreamingMessage']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['SendStreamingMessage']._serialized_options = b'\202\323\344\223\0023\"\017/message:stream:\001*Z\035\"\030/{tenant}/message:stream:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['GetTask']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetTask']._serialized_options = b'\332A\002id\202\323\344\223\002)\022\r/tasks/{id=*}Z\030\022\026/{tenant}/tasks/{id=*}'
+  _globals['_A2ASERVICE'].methods_by_name['ListTasks']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['ListTasks']._serialized_options = b'\202\323\344\223\002\033\022\006/tasksZ\021\022\017/{tenant}/tasks'
+  _globals['_A2ASERVICE'].methods_by_name['CancelTask']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['CancelTask']._serialized_options = b'\202\323\344\223\002=\"\024/tasks/{id=*}:cancel:\001*Z\"\"\035/{tenant}/tasks/{id=*}:cancel:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['SubscribeToTask']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['SubscribeToTask']._serialized_options = b'\202\323\344\223\002=\022\027/tasks/{id=*}:subscribeZ\"\022 /{tenant}/tasks/{id=*}:subscribe'
+  _globals['_A2ASERVICE'].methods_by_name['CreateTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['CreateTaskPushNotificationConfig']._serialized_options = b'\332A\016task_id,config\202\323\344\223\002i\"*/tasks/{task_id=*}/pushNotificationConfigs:\001*Z8\"3/{tenant}/tasks/{task_id=*}/pushNotificationConfigs:\001*'
+  _globals['_A2ASERVICE'].methods_by_name['GetTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetTaskPushNotificationConfig']._serialized_options = b'\332A\ntask_id,id\202\323\344\223\002q\0221/tasks/{task_id=*}/pushNotificationConfigs/{id=*}Z<\022:/{tenant}/tasks/{task_id=*}/pushNotificationConfigs/{id=*}'
+  _globals['_A2ASERVICE'].methods_by_name['ListTaskPushNotificationConfigs']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['ListTaskPushNotificationConfigs']._serialized_options = b'\332A\007task_id\202\323\344\223\002c\022*/tasks/{task_id=*}/pushNotificationConfigsZ5\0223/{tenant}/tasks/{task_id=*}/pushNotificationConfigs'
+  _globals['_A2ASERVICE'].methods_by_name['GetExtendedAgentCard']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['GetExtendedAgentCard']._serialized_options = b'\202\323\344\223\0023\022\022/extendedAgentCardZ\035\022\033/{tenant}/extendedAgentCard'
+  _globals['_A2ASERVICE'].methods_by_name['DeleteTaskPushNotificationConfig']._loaded_options = None
+  _globals['_A2ASERVICE'].methods_by_name['DeleteTaskPushNotificationConfig']._serialized_options = b'\332A\ntask_id,id\202\323\344\223\002q*1/tasks/{task_id=*}/pushNotificationConfigs/{id=*}Z<*:/{tenant}/tasks/{task_id=*}/pushNotificationConfigs/{id=*}'
+  _globals['_TASKSTATE']._serialized_start=9615
+  _globals['_TASKSTATE']._serialized_end=9864
+  _globals['_ROLE']._serialized_start=9866
+  _globals['_ROLE']._serialized_end=9925
+  _globals['_SENDMESSAGECONFIGURATION']._serialized_start=205
+  _globals['_SENDMESSAGECONFIGURATION']._serialized_end=499
+  _globals['_TASK']._serialized_start=502
+  _globals['_TASK']._serialized_end=762
+  _globals['_TASKSTATUS']._serialized_start=765
+  _globals['_TASKSTATUS']._serialized_end=930
+  _globals['_PART']._serialized_start=933
+  _globals['_PART']._serialized_end=1170
+  _globals['_MESSAGE']._serialized_start=1173
+  _globals['_MESSAGE']._serialized_end=1491
+  _globals['_ARTIFACT']._serialized_start=1494
+  _globals['_ARTIFACT']._serialized_end=1725
+  _globals['_TASKSTATUSUPDATEEVENT']._serialized_start=1728
+  _globals['_TASKSTATUSUPDATEEVENT']._serialized_end=1922
+  _globals['_TASKARTIFACTUPDATEEVENT']._serialized_start=1925
+  _globals['_TASKARTIFACTUPDATEEVENT']._serialized_end=2178
+  _globals['_AUTHENTICATIONINFO']._serialized_start=2180
+  _globals['_AUTHENTICATIONINFO']._serialized_end=2263
+  _globals['_AGENTINTERFACE']._serialized_start=2266
+  _globals['_AGENTINTERFACE']._serialized_end=2425
+  _globals['_AGENTCARD']._serialized_start=2428
+  _globals['_AGENTCARD']._serialized_end=3348
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_start=3220
+  _globals['_AGENTCARD_SECURITYSCHEMESENTRY']._serialized_end=3313
+  _globals['_AGENTPROVIDER']._serialized_start=3350
+  _globals['_AGENTPROVIDER']._serialized_end=3429
+  _globals['_AGENTCAPABILITIES']._serialized_start=3432
+  _globals['_AGENTCAPABILITIES']._serialized_end=3711
+  _globals['_AGENTEXTENSION']._serialized_start=3714
+  _globals['_AGENTEXTENSION']._serialized_end=3859
+  _globals['_AGENTSKILL']._serialized_start=3862
+  _globals['_AGENTSKILL']._serialized_end=4165
+  _globals['_AGENTCARDSIGNATURE']._serialized_start=4168
+  _globals['_AGENTCARDSIGNATURE']._serialized_end=4307
+  _globals['_TASKPUSHNOTIFICATIONCONFIG']._serialized_start=4310
+  _globals['_TASKPUSHNOTIFICATIONCONFIG']._serialized_end=4519
+  _globals['_STRINGLIST']._serialized_start=4521
+  _globals['_STRINGLIST']._serialized_end=4553
+  _globals['_SECURITYREQUIREMENT']._serialized_start=4556
+  _globals['_SECURITYREQUIREMENT']._serialized_end=4731
+  _globals['_SECURITYREQUIREMENT_SCHEMESENTRY']._serialized_start=4650
+  _globals['_SECURITYREQUIREMENT_SCHEMESENTRY']._serialized_end=4731
+  _globals['_SECURITYSCHEME']._serialized_start=4734
+  _globals['_SECURITYSCHEME']._serialized_end=5235
+  _globals['_APIKEYSECURITYSCHEME']._serialized_start=5237
+  _globals['_APIKEYSECURITYSCHEME']._serialized_end=5351
+  _globals['_HTTPAUTHSECURITYSCHEME']._serialized_start=5353
+  _globals['_HTTPAUTHSECURITYSCHEME']._serialized_end=5477
+  _globals['_OAUTH2SECURITYSCHEME']._serialized_start=5480
+  _globals['_OAUTH2SECURITYSCHEME']._serialized_end=5634
+  _globals['_OPENIDCONNECTSECURITYSCHEME']._serialized_start=5636
+  _globals['_OPENIDCONNECTSECURITYSCHEME']._serialized_end=5751
+  _globals['_MUTUALTLSSECURITYSCHEME']._serialized_start=5753
+  _globals['_MUTUALTLSSECURITYSCHEME']._serialized_end=5812
+  _globals['_OAUTHFLOWS']._serialized_start=5815
+  _globals['_OAUTHFLOWS']._serialized_end=6206
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW']._serialized_start=6209
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW']._serialized_end=6530
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_start=6473
+  _globals['_AUTHORIZATIONCODEOAUTHFLOW_SCOPESENTRY']._serialized_end=6530
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW']._serialized_start=6533
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW']._serialized_end=6767
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_start=6473
+  _globals['_CLIENTCREDENTIALSOAUTHFLOW_SCOPESENTRY']._serialized_end=6530
+  _globals['_IMPLICITOAUTHFLOW']._serialized_start=6770
+  _globals['_IMPLICITOAUTHFLOW']._serialized_end=6992
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_start=6473
+  _globals['_IMPLICITOAUTHFLOW_SCOPESENTRY']._serialized_end=6530
+  _globals['_PASSWORDOAUTHFLOW']._serialized_start=6995
+  _globals['_PASSWORDOAUTHFLOW']._serialized_end=7201
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_start=6473
+  _globals['_PASSWORDOAUTHFLOW_SCOPESENTRY']._serialized_end=6530
+  _globals['_DEVICECODEOAUTHFLOW']._serialized_start=7204
+  _globals['_DEVICECODEOAUTHFLOW']._serialized_end=7487
+  _globals['_DEVICECODEOAUTHFLOW_SCOPESENTRY']._serialized_start=6473
+  _globals['_DEVICECODEOAUTHFLOW_SCOPESENTRY']._serialized_end=6530
+  _globals['_SENDMESSAGEREQUEST']._serialized_start=7490
+  _globals['_SENDMESSAGEREQUEST']._serialized_end=7713
+  _globals['_GETTASKREQUEST']._serialized_start=7715
+  _globals['_GETTASKREQUEST']._serialized_end=7839
+  _globals['_LISTTASKSREQUEST']._serialized_start=7842
+  _globals['_LISTTASKSREQUEST']._serialized_end=8257
+  _globals['_LISTTASKSRESPONSE']._serialized_start=8260
+  _globals['_LISTTASKSRESPONSE']._serialized_end=8438
+  _globals['_CANCELTASKREQUEST']._serialized_start=8440
+  _globals['_CANCELTASKREQUEST']._serialized_end=8557
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=8559
+  _globals['_GETTASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=8672
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_start=8674
+  _globals['_DELETETASKPUSHNOTIFICATIONCONFIGREQUEST']._serialized_end=8790
+  _globals['_SUBSCRIBETOTASKREQUEST']._serialized_start=8792
+  _globals['_SUBSCRIBETOTASKREQUEST']._serialized_end=8861
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSREQUEST']._serialized_start=8864
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSREQUEST']._serialized_end=9018
+  _globals['_GETEXTENDEDAGENTCARDREQUEST']._serialized_start=9020
+  _globals['_GETEXTENDEDAGENTCARDREQUEST']._serialized_end=9073
+  _globals['_SENDMESSAGERESPONSE']._serialized_start=9075
+  _globals['_SENDMESSAGERESPONSE']._serialized_end=9194
+  _globals['_STREAMRESPONSE']._serialized_start=9197
+  _globals['_STREAMRESPONSE']._serialized_end=9463
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSRESPONSE']._serialized_start=9466
+  _globals['_LISTTASKPUSHNOTIFICATIONCONFIGSRESPONSE']._serialized_end=9612
+  _globals['_A2ASERVICE']._serialized_start=9928
+  _globals['_A2ASERVICE']._serialized_end=11871
+# @@protoc_insertion_point(module_scope)
diff --git a/src/a2a/types/a2a_pb2.pyi b/src/a2a/types/a2a_pb2.pyi
new file mode 100644
index 000000000..7da2f649e
--- /dev/null
+++ b/src/a2a/types/a2a_pb2.pyi
@@ -0,0 +1,623 @@
+import datetime
+
+from google.api import annotations_pb2 as _annotations_pb2
+from google.api import client_pb2 as _client_pb2
+from google.api import field_behavior_pb2 as _field_behavior_pb2
+from google.protobuf import empty_pb2 as _empty_pb2
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf import timestamp_pb2 as _timestamp_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class TaskState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    TASK_STATE_UNSPECIFIED: _ClassVar[TaskState]
+    TASK_STATE_SUBMITTED: _ClassVar[TaskState]
+    TASK_STATE_WORKING: _ClassVar[TaskState]
+    TASK_STATE_COMPLETED: _ClassVar[TaskState]
+    TASK_STATE_FAILED: _ClassVar[TaskState]
+    TASK_STATE_CANCELED: _ClassVar[TaskState]
+    TASK_STATE_INPUT_REQUIRED: _ClassVar[TaskState]
+    TASK_STATE_REJECTED: _ClassVar[TaskState]
+    TASK_STATE_AUTH_REQUIRED: _ClassVar[TaskState]
+
+class Role(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    ROLE_UNSPECIFIED: _ClassVar[Role]
+    ROLE_USER: _ClassVar[Role]
+    ROLE_AGENT: _ClassVar[Role]
+TASK_STATE_UNSPECIFIED: TaskState
+TASK_STATE_SUBMITTED: TaskState
+TASK_STATE_WORKING: TaskState
+TASK_STATE_COMPLETED: TaskState
+TASK_STATE_FAILED: TaskState
+TASK_STATE_CANCELED: TaskState
+TASK_STATE_INPUT_REQUIRED: TaskState
+TASK_STATE_REJECTED: TaskState
+TASK_STATE_AUTH_REQUIRED: TaskState
+ROLE_UNSPECIFIED: Role
+ROLE_USER: Role
+ROLE_AGENT: Role
+
+class SendMessageConfiguration(_message.Message):
+    __slots__ = ("accepted_output_modes", "task_push_notification_config", "history_length", "return_immediately")
+    ACCEPTED_OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    TASK_PUSH_NOTIFICATION_CONFIG_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    RETURN_IMMEDIATELY_FIELD_NUMBER: _ClassVar[int]
+    accepted_output_modes: _containers.RepeatedScalarFieldContainer[str]
+    task_push_notification_config: TaskPushNotificationConfig
+    history_length: int
+    return_immediately: bool
+    def __init__(self, accepted_output_modes: _Optional[_Iterable[str]] = ..., task_push_notification_config: _Optional[_Union[TaskPushNotificationConfig, _Mapping]] = ..., history_length: _Optional[int] = ..., return_immediately: _Optional[bool] = ...) -> None: ...
+
+class Task(_message.Message):
+    __slots__ = ("id", "context_id", "status", "artifacts", "history", "metadata")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACTS_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    context_id: str
+    status: TaskStatus
+    artifacts: _containers.RepeatedCompositeFieldContainer[Artifact]
+    history: _containers.RepeatedCompositeFieldContainer[Message]
+    metadata: _struct_pb2.Struct
+    def __init__(self, id: _Optional[str] = ..., context_id: _Optional[str] = ..., status: _Optional[_Union[TaskStatus, _Mapping]] = ..., artifacts: _Optional[_Iterable[_Union[Artifact, _Mapping]]] = ..., history: _Optional[_Iterable[_Union[Message, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskStatus(_message.Message):
+    __slots__ = ("state", "message", "timestamp")
+    STATE_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
+    state: TaskState
+    message: Message
+    timestamp: _timestamp_pb2.Timestamp
+    def __init__(self, state: _Optional[_Union[TaskState, str]] = ..., message: _Optional[_Union[Message, _Mapping]] = ..., timestamp: _Optional[_Union[datetime.datetime, _timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ...
+
+class Part(_message.Message):
+    __slots__ = ("text", "raw", "url", "data", "metadata", "filename", "media_type")
+    TEXT_FIELD_NUMBER: _ClassVar[int]
+    RAW_FIELD_NUMBER: _ClassVar[int]
+    URL_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    FILENAME_FIELD_NUMBER: _ClassVar[int]
+    MEDIA_TYPE_FIELD_NUMBER: _ClassVar[int]
+    text: str
+    raw: bytes
+    url: str
+    data: _struct_pb2.Value
+    metadata: _struct_pb2.Struct
+    filename: str
+    media_type: str
+    def __init__(self, text: _Optional[str] = ..., raw: _Optional[bytes] = ..., url: _Optional[str] = ..., data: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., filename: _Optional[str] = ..., media_type: _Optional[str] = ...) -> None: ...
+
+class Message(_message.Message):
+    __slots__ = ("message_id", "context_id", "task_id", "role", "parts", "metadata", "extensions", "reference_task_ids")
+    MESSAGE_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    ROLE_FIELD_NUMBER: _ClassVar[int]
+    PARTS_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    REFERENCE_TASK_IDS_FIELD_NUMBER: _ClassVar[int]
+    message_id: str
+    context_id: str
+    task_id: str
+    role: Role
+    parts: _containers.RepeatedCompositeFieldContainer[Part]
+    metadata: _struct_pb2.Struct
+    extensions: _containers.RepeatedScalarFieldContainer[str]
+    reference_task_ids: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, message_id: _Optional[str] = ..., context_id: _Optional[str] = ..., task_id: _Optional[str] = ..., role: _Optional[_Union[Role, str]] = ..., parts: _Optional[_Iterable[_Union[Part, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., extensions: _Optional[_Iterable[str]] = ..., reference_task_ids: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class Artifact(_message.Message):
+    __slots__ = ("artifact_id", "name", "description", "parts", "metadata", "extensions")
+    ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    PARTS_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    artifact_id: str
+    name: str
+    description: str
+    parts: _containers.RepeatedCompositeFieldContainer[Part]
+    metadata: _struct_pb2.Struct
+    extensions: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, artifact_id: _Optional[str] = ..., name: _Optional[str] = ..., description: _Optional[str] = ..., parts: _Optional[_Iterable[_Union[Part, _Mapping]]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., extensions: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class TaskStatusUpdateEvent(_message.Message):
+    __slots__ = ("task_id", "context_id", "status", "metadata")
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    task_id: str
+    context_id: str
+    status: TaskStatus
+    metadata: _struct_pb2.Struct
+    def __init__(self, task_id: _Optional[str] = ..., context_id: _Optional[str] = ..., status: _Optional[_Union[TaskStatus, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskArtifactUpdateEvent(_message.Message):
+    __slots__ = ("task_id", "context_id", "artifact", "append", "last_chunk", "metadata")
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACT_FIELD_NUMBER: _ClassVar[int]
+    APPEND_FIELD_NUMBER: _ClassVar[int]
+    LAST_CHUNK_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    task_id: str
+    context_id: str
+    artifact: Artifact
+    append: bool
+    last_chunk: bool
+    metadata: _struct_pb2.Struct
+    def __init__(self, task_id: _Optional[str] = ..., context_id: _Optional[str] = ..., artifact: _Optional[_Union[Artifact, _Mapping]] = ..., append: _Optional[bool] = ..., last_chunk: _Optional[bool] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class AuthenticationInfo(_message.Message):
+    __slots__ = ("scheme", "credentials")
+    SCHEME_FIELD_NUMBER: _ClassVar[int]
+    CREDENTIALS_FIELD_NUMBER: _ClassVar[int]
+    scheme: str
+    credentials: str
+    def __init__(self, scheme: _Optional[str] = ..., credentials: _Optional[str] = ...) -> None: ...
+
+class AgentInterface(_message.Message):
+    __slots__ = ("url", "protocol_binding", "tenant", "protocol_version")
+    URL_FIELD_NUMBER: _ClassVar[int]
+    PROTOCOL_BINDING_FIELD_NUMBER: _ClassVar[int]
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    PROTOCOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    url: str
+    protocol_binding: str
+    tenant: str
+    protocol_version: str
+    def __init__(self, url: _Optional[str] = ..., protocol_binding: _Optional[str] = ..., tenant: _Optional[str] = ..., protocol_version: _Optional[str] = ...) -> None: ...
+
+class AgentCard(_message.Message):
+    __slots__ = ("name", "description", "supported_interfaces", "provider", "version", "documentation_url", "capabilities", "security_schemes", "security_requirements", "default_input_modes", "default_output_modes", "skills", "signatures", "icon_url")
+    class SecuritySchemesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: SecurityScheme
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[SecurityScheme, _Mapping]] = ...) -> None: ...
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    SUPPORTED_INTERFACES_FIELD_NUMBER: _ClassVar[int]
+    PROVIDER_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    DOCUMENTATION_URL_FIELD_NUMBER: _ClassVar[int]
+    CAPABILITIES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_SCHEMES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_REQUIREMENTS_FIELD_NUMBER: _ClassVar[int]
+    DEFAULT_INPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    DEFAULT_OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    SKILLS_FIELD_NUMBER: _ClassVar[int]
+    SIGNATURES_FIELD_NUMBER: _ClassVar[int]
+    ICON_URL_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    description: str
+    supported_interfaces: _containers.RepeatedCompositeFieldContainer[AgentInterface]
+    provider: AgentProvider
+    version: str
+    documentation_url: str
+    capabilities: AgentCapabilities
+    security_schemes: _containers.MessageMap[str, SecurityScheme]
+    security_requirements: _containers.RepeatedCompositeFieldContainer[SecurityRequirement]
+    default_input_modes: _containers.RepeatedScalarFieldContainer[str]
+    default_output_modes: _containers.RepeatedScalarFieldContainer[str]
+    skills: _containers.RepeatedCompositeFieldContainer[AgentSkill]
+    signatures: _containers.RepeatedCompositeFieldContainer[AgentCardSignature]
+    icon_url: str
+    def __init__(self, name: _Optional[str] = ..., description: _Optional[str] = ..., supported_interfaces: _Optional[_Iterable[_Union[AgentInterface, _Mapping]]] = ..., provider: _Optional[_Union[AgentProvider, _Mapping]] = ..., version: _Optional[str] = ..., documentation_url: _Optional[str] = ..., capabilities: _Optional[_Union[AgentCapabilities, _Mapping]] = ..., security_schemes: _Optional[_Mapping[str, SecurityScheme]] = ..., security_requirements: _Optional[_Iterable[_Union[SecurityRequirement, _Mapping]]] = ..., default_input_modes: _Optional[_Iterable[str]] = ..., default_output_modes: _Optional[_Iterable[str]] = ..., skills: _Optional[_Iterable[_Union[AgentSkill, _Mapping]]] = ..., signatures: _Optional[_Iterable[_Union[AgentCardSignature, _Mapping]]] = ..., icon_url: _Optional[str] = ...) -> None: ...
+
+class AgentProvider(_message.Message):
+    __slots__ = ("url", "organization")
+    URL_FIELD_NUMBER: _ClassVar[int]
+    ORGANIZATION_FIELD_NUMBER: _ClassVar[int]
+    url: str
+    organization: str
+    def __init__(self, url: _Optional[str] = ..., organization: _Optional[str] = ...) -> None: ...
+
+class AgentCapabilities(_message.Message):
+    __slots__ = ("streaming", "push_notifications", "extensions", "extended_agent_card")
+    STREAMING_FIELD_NUMBER: _ClassVar[int]
+    PUSH_NOTIFICATIONS_FIELD_NUMBER: _ClassVar[int]
+    EXTENSIONS_FIELD_NUMBER: _ClassVar[int]
+    EXTENDED_AGENT_CARD_FIELD_NUMBER: _ClassVar[int]
+    streaming: bool
+    push_notifications: bool
+    extensions: _containers.RepeatedCompositeFieldContainer[AgentExtension]
+    extended_agent_card: bool
+    def __init__(self, streaming: _Optional[bool] = ..., push_notifications: _Optional[bool] = ..., extensions: _Optional[_Iterable[_Union[AgentExtension, _Mapping]]] = ..., extended_agent_card: _Optional[bool] = ...) -> None: ...
+
+class AgentExtension(_message.Message):
+    __slots__ = ("uri", "description", "required", "params")
+    URI_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    REQUIRED_FIELD_NUMBER: _ClassVar[int]
+    PARAMS_FIELD_NUMBER: _ClassVar[int]
+    uri: str
+    description: str
+    required: bool
+    params: _struct_pb2.Struct
+    def __init__(self, uri: _Optional[str] = ..., description: _Optional[str] = ..., required: _Optional[bool] = ..., params: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class AgentSkill(_message.Message):
+    __slots__ = ("id", "name", "description", "tags", "examples", "input_modes", "output_modes", "security_requirements")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    TAGS_FIELD_NUMBER: _ClassVar[int]
+    EXAMPLES_FIELD_NUMBER: _ClassVar[int]
+    INPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    OUTPUT_MODES_FIELD_NUMBER: _ClassVar[int]
+    SECURITY_REQUIREMENTS_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    name: str
+    description: str
+    tags: _containers.RepeatedScalarFieldContainer[str]
+    examples: _containers.RepeatedScalarFieldContainer[str]
+    input_modes: _containers.RepeatedScalarFieldContainer[str]
+    output_modes: _containers.RepeatedScalarFieldContainer[str]
+    security_requirements: _containers.RepeatedCompositeFieldContainer[SecurityRequirement]
+    def __init__(self, id: _Optional[str] = ..., name: _Optional[str] = ..., description: _Optional[str] = ..., tags: _Optional[_Iterable[str]] = ..., examples: _Optional[_Iterable[str]] = ..., input_modes: _Optional[_Iterable[str]] = ..., output_modes: _Optional[_Iterable[str]] = ..., security_requirements: _Optional[_Iterable[_Union[SecurityRequirement, _Mapping]]] = ...) -> None: ...
+
+class AgentCardSignature(_message.Message):
+    __slots__ = ("protected", "signature", "header")
+    PROTECTED_FIELD_NUMBER: _ClassVar[int]
+    SIGNATURE_FIELD_NUMBER: _ClassVar[int]
+    HEADER_FIELD_NUMBER: _ClassVar[int]
+    protected: str
+    signature: str
+    header: _struct_pb2.Struct
+    def __init__(self, protected: _Optional[str] = ..., signature: _Optional[str] = ..., header: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class TaskPushNotificationConfig(_message.Message):
+    __slots__ = ("tenant", "id", "task_id", "url", "token", "authentication")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    URL_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_FIELD_NUMBER: _ClassVar[int]
+    AUTHENTICATION_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    id: str
+    task_id: str
+    url: str
+    token: str
+    authentication: AuthenticationInfo
+    def __init__(self, tenant: _Optional[str] = ..., id: _Optional[str] = ..., task_id: _Optional[str] = ..., url: _Optional[str] = ..., token: _Optional[str] = ..., authentication: _Optional[_Union[AuthenticationInfo, _Mapping]] = ...) -> None: ...
+
+class StringList(_message.Message):
+    __slots__ = ("list",)
+    LIST_FIELD_NUMBER: _ClassVar[int]
+    list: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, list: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class SecurityRequirement(_message.Message):
+    __slots__ = ("schemes",)
+    class SchemesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: StringList
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[StringList, _Mapping]] = ...) -> None: ...
+    SCHEMES_FIELD_NUMBER: _ClassVar[int]
+    schemes: _containers.MessageMap[str, StringList]
+    def __init__(self, schemes: _Optional[_Mapping[str, StringList]] = ...) -> None: ...
+
+class SecurityScheme(_message.Message):
+    __slots__ = ("api_key_security_scheme", "http_auth_security_scheme", "oauth2_security_scheme", "open_id_connect_security_scheme", "mtls_security_scheme")
+    API_KEY_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    HTTP_AUTH_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    OAUTH2_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    OPEN_ID_CONNECT_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    MTLS_SECURITY_SCHEME_FIELD_NUMBER: _ClassVar[int]
+    api_key_security_scheme: APIKeySecurityScheme
+    http_auth_security_scheme: HTTPAuthSecurityScheme
+    oauth2_security_scheme: OAuth2SecurityScheme
+    open_id_connect_security_scheme: OpenIdConnectSecurityScheme
+    mtls_security_scheme: MutualTlsSecurityScheme
+    def __init__(self, api_key_security_scheme: _Optional[_Union[APIKeySecurityScheme, _Mapping]] = ..., http_auth_security_scheme: _Optional[_Union[HTTPAuthSecurityScheme, _Mapping]] = ..., oauth2_security_scheme: _Optional[_Union[OAuth2SecurityScheme, _Mapping]] = ..., open_id_connect_security_scheme: _Optional[_Union[OpenIdConnectSecurityScheme, _Mapping]] = ..., mtls_security_scheme: _Optional[_Union[MutualTlsSecurityScheme, _Mapping]] = ...) -> None: ...
+
+class APIKeySecurityScheme(_message.Message):
+    __slots__ = ("description", "location", "name")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    LOCATION_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    location: str
+    name: str
+    def __init__(self, description: _Optional[str] = ..., location: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ...
+
+class HTTPAuthSecurityScheme(_message.Message):
+    __slots__ = ("description", "scheme", "bearer_format")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    SCHEME_FIELD_NUMBER: _ClassVar[int]
+    BEARER_FORMAT_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    scheme: str
+    bearer_format: str
+    def __init__(self, description: _Optional[str] = ..., scheme: _Optional[str] = ..., bearer_format: _Optional[str] = ...) -> None: ...
+
+class OAuth2SecurityScheme(_message.Message):
+    __slots__ = ("description", "flows", "oauth2_metadata_url")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    FLOWS_FIELD_NUMBER: _ClassVar[int]
+    OAUTH2_METADATA_URL_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    flows: OAuthFlows
+    oauth2_metadata_url: str
+    def __init__(self, description: _Optional[str] = ..., flows: _Optional[_Union[OAuthFlows, _Mapping]] = ..., oauth2_metadata_url: _Optional[str] = ...) -> None: ...
+
+class OpenIdConnectSecurityScheme(_message.Message):
+    __slots__ = ("description", "open_id_connect_url")
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    OPEN_ID_CONNECT_URL_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    open_id_connect_url: str
+    def __init__(self, description: _Optional[str] = ..., open_id_connect_url: _Optional[str] = ...) -> None: ...
+
+class MutualTlsSecurityScheme(_message.Message):
+    __slots__ = ("description",)
+    DESCRIPTION_FIELD_NUMBER: _ClassVar[int]
+    description: str
+    def __init__(self, description: _Optional[str] = ...) -> None: ...
+
+class OAuthFlows(_message.Message):
+    __slots__ = ("authorization_code", "client_credentials", "implicit", "password", "device_code")
+    AUTHORIZATION_CODE_FIELD_NUMBER: _ClassVar[int]
+    CLIENT_CREDENTIALS_FIELD_NUMBER: _ClassVar[int]
+    IMPLICIT_FIELD_NUMBER: _ClassVar[int]
+    PASSWORD_FIELD_NUMBER: _ClassVar[int]
+    DEVICE_CODE_FIELD_NUMBER: _ClassVar[int]
+    authorization_code: AuthorizationCodeOAuthFlow
+    client_credentials: ClientCredentialsOAuthFlow
+    implicit: ImplicitOAuthFlow
+    password: PasswordOAuthFlow
+    device_code: DeviceCodeOAuthFlow
+    def __init__(self, authorization_code: _Optional[_Union[AuthorizationCodeOAuthFlow, _Mapping]] = ..., client_credentials: _Optional[_Union[ClientCredentialsOAuthFlow, _Mapping]] = ..., implicit: _Optional[_Union[ImplicitOAuthFlow, _Mapping]] = ..., password: _Optional[_Union[PasswordOAuthFlow, _Mapping]] = ..., device_code: _Optional[_Union[DeviceCodeOAuthFlow, _Mapping]] = ...) -> None: ...
+
+class AuthorizationCodeOAuthFlow(_message.Message):
+    __slots__ = ("authorization_url", "token_url", "refresh_url", "scopes", "pkce_required")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    PKCE_REQUIRED_FIELD_NUMBER: _ClassVar[int]
+    authorization_url: str
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    pkce_required: bool
+    def __init__(self, authorization_url: _Optional[str] = ..., token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ..., pkce_required: _Optional[bool] = ...) -> None: ...
+
+class ClientCredentialsOAuthFlow(_message.Message):
+    __slots__ = ("token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class ImplicitOAuthFlow(_message.Message):
+    __slots__ = ("authorization_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    authorization_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, authorization_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class PasswordOAuthFlow(_message.Message):
+    __slots__ = ("token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class DeviceCodeOAuthFlow(_message.Message):
+    __slots__ = ("device_authorization_url", "token_url", "refresh_url", "scopes")
+    class ScopesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    DEVICE_AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_URL_FIELD_NUMBER: _ClassVar[int]
+    REFRESH_URL_FIELD_NUMBER: _ClassVar[int]
+    SCOPES_FIELD_NUMBER: _ClassVar[int]
+    device_authorization_url: str
+    token_url: str
+    refresh_url: str
+    scopes: _containers.ScalarMap[str, str]
+    def __init__(self, device_authorization_url: _Optional[str] = ..., token_url: _Optional[str] = ..., refresh_url: _Optional[str] = ..., scopes: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class SendMessageRequest(_message.Message):
+    __slots__ = ("tenant", "message", "configuration", "metadata")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    CONFIGURATION_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    message: Message
+    configuration: SendMessageConfiguration
+    metadata: _struct_pb2.Struct
+    def __init__(self, tenant: _Optional[str] = ..., message: _Optional[_Union[Message, _Mapping]] = ..., configuration: _Optional[_Union[SendMessageConfiguration, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class GetTaskRequest(_message.Message):
+    __slots__ = ("tenant", "id", "history_length")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    id: str
+    history_length: int
+    def __init__(self, tenant: _Optional[str] = ..., id: _Optional[str] = ..., history_length: _Optional[int] = ...) -> None: ...
+
+class ListTasksRequest(_message.Message):
+    __slots__ = ("tenant", "context_id", "status", "page_size", "page_token", "history_length", "status_timestamp_after", "include_artifacts")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    PAGE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    HISTORY_LENGTH_FIELD_NUMBER: _ClassVar[int]
+    STATUS_TIMESTAMP_AFTER_FIELD_NUMBER: _ClassVar[int]
+    INCLUDE_ARTIFACTS_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    context_id: str
+    status: TaskState
+    page_size: int
+    page_token: str
+    history_length: int
+    status_timestamp_after: _timestamp_pb2.Timestamp
+    include_artifacts: bool
+    def __init__(self, tenant: _Optional[str] = ..., context_id: _Optional[str] = ..., status: _Optional[_Union[TaskState, str]] = ..., page_size: _Optional[int] = ..., page_token: _Optional[str] = ..., history_length: _Optional[int] = ..., status_timestamp_after: _Optional[_Union[datetime.datetime, _timestamp_pb2.Timestamp, _Mapping]] = ..., include_artifacts: _Optional[bool] = ...) -> None: ...
+
+class ListTasksResponse(_message.Message):
+    __slots__ = ("tasks", "next_page_token", "page_size", "total_size")
+    TASKS_FIELD_NUMBER: _ClassVar[int]
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    PAGE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    TOTAL_SIZE_FIELD_NUMBER: _ClassVar[int]
+    tasks: _containers.RepeatedCompositeFieldContainer[Task]
+    next_page_token: str
+    page_size: int
+    total_size: int
+    def __init__(self, tasks: _Optional[_Iterable[_Union[Task, _Mapping]]] = ..., next_page_token: _Optional[str] = ..., page_size: _Optional[int] = ..., total_size: _Optional[int] = ...) -> None: ...
+
+class CancelTaskRequest(_message.Message):
+    __slots__ = ("tenant", "id", "metadata")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    id: str
+    metadata: _struct_pb2.Struct
+    def __init__(self, tenant: _Optional[str] = ..., id: _Optional[str] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ...
+
+class GetTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("tenant", "task_id", "id")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    task_id: str
+    id: str
+    def __init__(self, tenant: _Optional[str] = ..., task_id: _Optional[str] = ..., id: _Optional[str] = ...) -> None: ...
+
+class DeleteTaskPushNotificationConfigRequest(_message.Message):
+    __slots__ = ("tenant", "task_id", "id")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    task_id: str
+    id: str
+    def __init__(self, tenant: _Optional[str] = ..., task_id: _Optional[str] = ..., id: _Optional[str] = ...) -> None: ...
+
+class SubscribeToTaskRequest(_message.Message):
+    __slots__ = ("tenant", "id")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    ID_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    id: str
+    def __init__(self, tenant: _Optional[str] = ..., id: _Optional[str] = ...) -> None: ...
+
+class ListTaskPushNotificationConfigsRequest(_message.Message):
+    __slots__ = ("tenant", "task_id", "page_size", "page_token")
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    PAGE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    task_id: str
+    page_size: int
+    page_token: str
+    def __init__(self, tenant: _Optional[str] = ..., task_id: _Optional[str] = ..., page_size: _Optional[int] = ..., page_token: _Optional[str] = ...) -> None: ...
+
+class GetExtendedAgentCardRequest(_message.Message):
+    __slots__ = ("tenant",)
+    TENANT_FIELD_NUMBER: _ClassVar[int]
+    tenant: str
+    def __init__(self, tenant: _Optional[str] = ...) -> None: ...
+
+class SendMessageResponse(_message.Message):
+    __slots__ = ("task", "message")
+    TASK_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    task: Task
+    message: Message
+    def __init__(self, task: _Optional[_Union[Task, _Mapping]] = ..., message: _Optional[_Union[Message, _Mapping]] = ...) -> None: ...
+
+class StreamResponse(_message.Message):
+    __slots__ = ("task", "message", "status_update", "artifact_update")
+    TASK_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    STATUS_UPDATE_FIELD_NUMBER: _ClassVar[int]
+    ARTIFACT_UPDATE_FIELD_NUMBER: _ClassVar[int]
+    task: Task
+    message: Message
+    status_update: TaskStatusUpdateEvent
+    artifact_update: TaskArtifactUpdateEvent
+    def __init__(self, task: _Optional[_Union[Task, _Mapping]] = ..., message: _Optional[_Union[Message, _Mapping]] = ..., status_update: _Optional[_Union[TaskStatusUpdateEvent, _Mapping]] = ..., artifact_update: _Optional[_Union[TaskArtifactUpdateEvent, _Mapping]] = ...) -> None: ...
+
+class ListTaskPushNotificationConfigsResponse(_message.Message):
+    __slots__ = ("configs", "next_page_token")
+    CONFIGS_FIELD_NUMBER: _ClassVar[int]
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    configs: _containers.RepeatedCompositeFieldContainer[TaskPushNotificationConfig]
+    next_page_token: str
+    def __init__(self, configs: _Optional[_Iterable[_Union[TaskPushNotificationConfig, _Mapping]]] = ..., next_page_token: _Optional[str] = ...) -> None: ...
diff --git a/src/a2a/types/a2a_pb2_grpc.py b/src/a2a/types/a2a_pb2_grpc.py
new file mode 100644
index 000000000..e969f3bd5
--- /dev/null
+++ b/src/a2a/types/a2a_pb2_grpc.py
@@ -0,0 +1,528 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from . import a2a_pb2 as a2a__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+
+
+class A2AServiceStub(object):
+    """Provides operations for interacting with agents using the A2A protocol.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SendMessage = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/SendMessage',
+                request_serializer=a2a__pb2.SendMessageRequest.SerializeToString,
+                response_deserializer=a2a__pb2.SendMessageResponse.FromString,
+                _registered_method=True)
+        self.SendStreamingMessage = channel.unary_stream(
+                '/lf.a2a.v1.A2AService/SendStreamingMessage',
+                request_serializer=a2a__pb2.SendMessageRequest.SerializeToString,
+                response_deserializer=a2a__pb2.StreamResponse.FromString,
+                _registered_method=True)
+        self.GetTask = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/GetTask',
+                request_serializer=a2a__pb2.GetTaskRequest.SerializeToString,
+                response_deserializer=a2a__pb2.Task.FromString,
+                _registered_method=True)
+        self.ListTasks = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/ListTasks',
+                request_serializer=a2a__pb2.ListTasksRequest.SerializeToString,
+                response_deserializer=a2a__pb2.ListTasksResponse.FromString,
+                _registered_method=True)
+        self.CancelTask = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/CancelTask',
+                request_serializer=a2a__pb2.CancelTaskRequest.SerializeToString,
+                response_deserializer=a2a__pb2.Task.FromString,
+                _registered_method=True)
+        self.SubscribeToTask = channel.unary_stream(
+                '/lf.a2a.v1.A2AService/SubscribeToTask',
+                request_serializer=a2a__pb2.SubscribeToTaskRequest.SerializeToString,
+                response_deserializer=a2a__pb2.StreamResponse.FromString,
+                _registered_method=True)
+        self.CreateTaskPushNotificationConfig = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/CreateTaskPushNotificationConfig',
+                request_serializer=a2a__pb2.TaskPushNotificationConfig.SerializeToString,
+                response_deserializer=a2a__pb2.TaskPushNotificationConfig.FromString,
+                _registered_method=True)
+        self.GetTaskPushNotificationConfig = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/GetTaskPushNotificationConfig',
+                request_serializer=a2a__pb2.GetTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=a2a__pb2.TaskPushNotificationConfig.FromString,
+                _registered_method=True)
+        self.ListTaskPushNotificationConfigs = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/ListTaskPushNotificationConfigs',
+                request_serializer=a2a__pb2.ListTaskPushNotificationConfigsRequest.SerializeToString,
+                response_deserializer=a2a__pb2.ListTaskPushNotificationConfigsResponse.FromString,
+                _registered_method=True)
+        self.GetExtendedAgentCard = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/GetExtendedAgentCard',
+                request_serializer=a2a__pb2.GetExtendedAgentCardRequest.SerializeToString,
+                response_deserializer=a2a__pb2.AgentCard.FromString,
+                _registered_method=True)
+        self.DeleteTaskPushNotificationConfig = channel.unary_unary(
+                '/lf.a2a.v1.A2AService/DeleteTaskPushNotificationConfig',
+                request_serializer=a2a__pb2.DeleteTaskPushNotificationConfigRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+
+
+class A2AServiceServicer(object):
+    """Provides operations for interacting with agents using the A2A protocol.
+    """
+
+    def SendMessage(self, request, context):
+        """Sends a message to an agent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SendStreamingMessage(self, request, context):
+        """Sends a streaming message to an agent, allowing for real-time interaction and status updates.
+        Streaming version of `SendMessage`
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTask(self, request, context):
+        """Gets the latest state of a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTasks(self, request, context):
+        """Lists tasks that match the specified filter.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def CancelTask(self, request, context):
+        """Cancels a task in progress.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SubscribeToTask(self, request, context):
+        """Subscribes to task updates for tasks not in a terminal state.
+        Returns `UnsupportedOperationError` if the task is already in a terminal state (completed, failed, canceled, rejected).
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def CreateTaskPushNotificationConfig(self, request, context):
+        """(-- api-linter: client-libraries::4232::required-fields=disabled
+        api-linter: core::0133::method-signature=disabled
+        api-linter: core::0133::request-message-name=disabled
+        aip.dev/not-precedent: method_signature preserved for backwards compatibility --)
+        Creates a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTaskPushNotificationConfig(self, request, context):
+        """Gets a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTaskPushNotificationConfigs(self, request, context):
+        """Get a list of push notifications configured for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetExtendedAgentCard(self, request, context):
+        """Gets the extended agent card for the authenticated agent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeleteTaskPushNotificationConfig(self, request, context):
+        """Deletes a push notification config for a task.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_A2AServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SendMessage': grpc.unary_unary_rpc_method_handler(
+                    servicer.SendMessage,
+                    request_deserializer=a2a__pb2.SendMessageRequest.FromString,
+                    response_serializer=a2a__pb2.SendMessageResponse.SerializeToString,
+            ),
+            'SendStreamingMessage': grpc.unary_stream_rpc_method_handler(
+                    servicer.SendStreamingMessage,
+                    request_deserializer=a2a__pb2.SendMessageRequest.FromString,
+                    response_serializer=a2a__pb2.StreamResponse.SerializeToString,
+            ),
+            'GetTask': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTask,
+                    request_deserializer=a2a__pb2.GetTaskRequest.FromString,
+                    response_serializer=a2a__pb2.Task.SerializeToString,
+            ),
+            'ListTasks': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTasks,
+                    request_deserializer=a2a__pb2.ListTasksRequest.FromString,
+                    response_serializer=a2a__pb2.ListTasksResponse.SerializeToString,
+            ),
+            'CancelTask': grpc.unary_unary_rpc_method_handler(
+                    servicer.CancelTask,
+                    request_deserializer=a2a__pb2.CancelTaskRequest.FromString,
+                    response_serializer=a2a__pb2.Task.SerializeToString,
+            ),
+            'SubscribeToTask': grpc.unary_stream_rpc_method_handler(
+                    servicer.SubscribeToTask,
+                    request_deserializer=a2a__pb2.SubscribeToTaskRequest.FromString,
+                    response_serializer=a2a__pb2.StreamResponse.SerializeToString,
+            ),
+            'CreateTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.CreateTaskPushNotificationConfig,
+                    request_deserializer=a2a__pb2.TaskPushNotificationConfig.FromString,
+                    response_serializer=a2a__pb2.TaskPushNotificationConfig.SerializeToString,
+            ),
+            'GetTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTaskPushNotificationConfig,
+                    request_deserializer=a2a__pb2.GetTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=a2a__pb2.TaskPushNotificationConfig.SerializeToString,
+            ),
+            'ListTaskPushNotificationConfigs': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTaskPushNotificationConfigs,
+                    request_deserializer=a2a__pb2.ListTaskPushNotificationConfigsRequest.FromString,
+                    response_serializer=a2a__pb2.ListTaskPushNotificationConfigsResponse.SerializeToString,
+            ),
+            'GetExtendedAgentCard': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetExtendedAgentCard,
+                    request_deserializer=a2a__pb2.GetExtendedAgentCardRequest.FromString,
+                    response_serializer=a2a__pb2.AgentCard.SerializeToString,
+            ),
+            'DeleteTaskPushNotificationConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeleteTaskPushNotificationConfig,
+                    request_deserializer=a2a__pb2.DeleteTaskPushNotificationConfigRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'lf.a2a.v1.A2AService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('lf.a2a.v1.A2AService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class A2AService(object):
+    """Provides operations for interacting with agents using the A2A protocol.
+    """
+
+    @staticmethod
+    def SendMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/SendMessage',
+            a2a__pb2.SendMessageRequest.SerializeToString,
+            a2a__pb2.SendMessageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SendStreamingMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/SendStreamingMessage',
+            a2a__pb2.SendMessageRequest.SerializeToString,
+            a2a__pb2.StreamResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetTask(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/GetTask',
+            a2a__pb2.GetTaskRequest.SerializeToString,
+            a2a__pb2.Task.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListTasks(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/ListTasks',
+            a2a__pb2.ListTasksRequest.SerializeToString,
+            a2a__pb2.ListTasksResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def CancelTask(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/CancelTask',
+            a2a__pb2.CancelTaskRequest.SerializeToString,
+            a2a__pb2.Task.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SubscribeToTask(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/SubscribeToTask',
+            a2a__pb2.SubscribeToTaskRequest.SerializeToString,
+            a2a__pb2.StreamResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def CreateTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/CreateTaskPushNotificationConfig',
+            a2a__pb2.TaskPushNotificationConfig.SerializeToString,
+            a2a__pb2.TaskPushNotificationConfig.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/GetTaskPushNotificationConfig',
+            a2a__pb2.GetTaskPushNotificationConfigRequest.SerializeToString,
+            a2a__pb2.TaskPushNotificationConfig.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListTaskPushNotificationConfigs(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/ListTaskPushNotificationConfigs',
+            a2a__pb2.ListTaskPushNotificationConfigsRequest.SerializeToString,
+            a2a__pb2.ListTaskPushNotificationConfigsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetExtendedAgentCard(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/GetExtendedAgentCard',
+            a2a__pb2.GetExtendedAgentCardRequest.SerializeToString,
+            a2a__pb2.AgentCard.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def DeleteTaskPushNotificationConfig(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/lf.a2a.v1.A2AService/DeleteTaskPushNotificationConfig',
+            a2a__pb2.DeleteTaskPushNotificationConfigRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
diff --git a/src/a2a/utils/__init__.py b/src/a2a/utils/__init__.py
index 42e5d37e9..04693dd0b 100644
--- a/src/a2a/utils/__init__.py
+++ b/src/a2a/utils/__init__.py
@@ -1,24 +1,18 @@
-from a2a.utils.artifact import new_text_artifact
-from a2a.utils.helpers import (
-    append_artifact_to_task,
-    build_text_artifact,
-    create_task_obj,
-)
-from a2a.utils.message import (
-    get_message_text,
-    get_text_parts,
-    new_agent_text_message,
+"""Utility functions for the A2A Python SDK."""
+
+from a2a.utils import proto_utils
+from a2a.utils.constants import (
+    AGENT_CARD_WELL_KNOWN_PATH,
+    DEFAULT_RPC_URL,
+    TransportProtocol,
 )
-from a2a.utils.task import new_task
+from a2a.utils.proto_utils import to_stream_response
 
 
 __all__ = [
-    'append_artifact_to_task',
-    'build_text_artifact',
-    'create_task_obj',
-    'get_message_text',
-    'get_text_parts',
-    'new_agent_text_message',
-    'new_task',
-    'new_text_artifact',
+    'AGENT_CARD_WELL_KNOWN_PATH',
+    'DEFAULT_RPC_URL',
+    'TransportProtocol',
+    'proto_utils',
+    'to_stream_response',
 ]
diff --git a/src/a2a/utils/_async_queue_compat.py b/src/a2a/utils/_async_queue_compat.py
new file mode 100644
index 000000000..078a221f9
--- /dev/null
+++ b/src/a2a/utils/_async_queue_compat.py
@@ -0,0 +1,28 @@
+"""Cross-version aliases for async queue primitives."""
+
+import sys
+
+from typing import Any
+
+
+if sys.version_info >= (3, 13):
+    from asyncio import Queue as AsyncQueue
+    from asyncio import QueueShutDown
+
+    def create_async_queue(maxsize: int = 0) -> AsyncQueue[Any]:
+        """Create a backwards-compatible async queue object."""
+        return AsyncQueue(maxsize=maxsize)
+else:
+    import culsans
+
+    from culsans import AsyncQueue  # type: ignore[no-redef]
+    from culsans import (
+        AsyncQueueShutDown as QueueShutDown,  # type: ignore[no-redef]
+    )
+
+    def create_async_queue(maxsize: int = 0) -> AsyncQueue[Any]:
+        """Create a backwards-compatible async queue object."""
+        return culsans.Queue(maxsize=maxsize).async_q  # type: ignore[no-any-return]
+
+
+__all__ = ['AsyncQueue', 'QueueShutDown', 'create_async_queue']
diff --git a/src/a2a/utils/_jcs.py b/src/a2a/utils/_jcs.py
new file mode 100644
index 000000000..90fcf67dd
--- /dev/null
+++ b/src/a2a/utils/_jcs.py
@@ -0,0 +1,233 @@
+"""RFC 8785 JSON Canonicalization Scheme (JCS).
+
+The Agent Card signature covers a canonical serialization of the card, so the
+bytes produced here are the bytes that get signed. `json.dumps` cannot produce
+them: it escapes non-ASCII by default, orders keys by code point rather than by
+UTF-16 code unit, and formats numbers with `repr` rather than with the
+ECMAScript `Number::toString` algorithm.
+
+Number formatting follows ECMA-262 7.1.12.1 as amended by RFC 8785 section
+3.2.2.3. That part of the algorithm is adapted from Anders Rundgren's reference
+implementation, which is published under the Apache License 2.0:
+https://github.com/cyberphone/json-canonicalization
+
+Serialization is depth-limited. Nesting is attacker-controlled through
+`AgentExtension.params`, which is a `google.protobuf.Struct` and so may nest
+arbitrarily, and an unbounded recursive serializer turns that into a crash in
+whatever process verifies the card.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+
+from typing import Any
+
+
+MAX_DEPTH = 128
+"""Maximum object/array nesting accepted by `canonicalize`.
+
+Deep enough that no plausible Agent Card reaches it, shallow enough that the
+recursion cannot exhaust the interpreter stack.
+"""
+
+# JSON numbers are IEEE 754 double-precision floats (RFC 8785 section 3.2.2.3),
+# so integers outside this range have no interoperable representation.
+_SAFE_INT_MAX = 2**53 - 1
+_SAFE_INT_MIN = -(2**53) + 1
+
+# ECMA-262 7.1.12.1 steps 6 and 8: outside this exponent window a number is
+# written in exponential notation, inside it the digits are written out in full.
+_EXPONENT_EXPANSION_CEILING = 21
+_EXPONENT_EXPANSION_FLOOR = -7
+
+# RFC 8785 section 3.2.2.2: escape the two mandatory characters and the C0
+# control range, and emit everything else as literal UTF-8.
+_ESCAPE_RE = re.compile(r'[\x00-\x1f\\"]')
+_ESCAPE_MAP = {
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+for _codepoint in range(0x20):
+    _ESCAPE_MAP.setdefault(chr(_codepoint), f'\\u{_codepoint:04x}')
+del _codepoint
+
+
+class CanonicalizationError(ValueError):
+    """Raised when a value has no RFC 8785 canonical form."""
+
+
+def canonicalize(obj: Any) -> str:
+    """Serializes `obj` to its RFC 8785 canonical form.
+
+    Args:
+        obj: A JSON value: `None`, `bool`, `int`, `float`, `str`, or a list or
+            dict of the same. Dict keys must be strings.
+
+    Returns:
+        The canonical serialization. The result is `str` rather than `bytes`
+        for the caller's convenience; RFC 8785 defines the canonical form as
+        the UTF-8 encoding of this string.
+
+    Raises:
+        CanonicalizationError: If `obj` contains a value with no canonical
+            form, a non-string key, unpaired surrogates, or nesting deeper
+            than `MAX_DEPTH`.
+    """
+    out: list[str] = []
+    _write(obj, out, 1)
+    canonical = ''.join(out)
+    try:
+        # RFC 8785 canonical output is UTF-8. Round-tripping here rejects
+        # unpaired surrogates, which have no UTF-8 encoding, rather than
+        # deferring the failure to whoever encodes the return value.
+        canonical.encode('utf-8')
+    except UnicodeEncodeError as e:
+        raise CanonicalizationError(
+            'value contains text that is not valid Unicode'
+        ) from e
+    return canonical
+
+
+def _write(obj: Any, out: list[str], depth: int) -> None:
+    """Appends the canonical form of `obj` to `out`.
+
+    `depth` is the number of open containers on the path to `obj`, the
+    outermost at 1. Only containers are recursed into, so only containers
+    carry a depth worth checking; a scalar's depth is never read.
+    """
+    if isinstance(obj, (list, tuple, dict)) and depth > MAX_DEPTH:
+        raise CanonicalizationError(
+            f'nesting exceeds the maximum depth of {MAX_DEPTH}'
+        )
+
+    if isinstance(obj, (list, tuple)):
+        out.append('[')
+        for index, element in enumerate(obj):
+            if index:
+                out.append(',')
+            _write(element, out, depth + 1)
+        out.append(']')
+    elif isinstance(obj, dict):
+        out.append('{')
+        for index, (key, value) in enumerate(_sorted_items(obj)):
+            if index:
+                out.append(',')
+            out.append(_quote(key))
+            out.append(':')
+            _write(value, out, depth + 1)
+        out.append('}')
+    else:
+        out.append(_format_scalar(obj))
+
+
+def _format_scalar(obj: Any) -> str:
+    """Returns the canonical form of a JSON scalar."""
+    if obj is None:
+        return 'null'
+    # bool is a subclass of int, so it has to be tested first.
+    if isinstance(obj, bool):
+        return 'true' if obj else 'false'
+    if isinstance(obj, int):
+        if obj < _SAFE_INT_MIN or obj > _SAFE_INT_MAX:
+            raise CanonicalizationError(
+                f'{obj} is outside the range of integers a JSON number can '
+                'represent exactly'
+            )
+        return str(obj)
+    if isinstance(obj, float):
+        return _format_number(obj)
+    if isinstance(obj, str):
+        return _quote(obj)
+    raise CanonicalizationError(
+        f'{type(obj).__name__} has no JSON representation'
+    )
+
+
+def _sorted_items(obj: dict[Any, Any]) -> list[tuple[str, Any]]:
+    """Sorts a dict's items by UTF-16 code unit, per RFC 8785 section 3.2.3.
+
+    Comparing big-endian UTF-16 encodings byte by byte is equivalent to
+    comparing the code unit sequences numerically, which is what the RFC
+    requires and what `sorted(..., key=str)` does not do: code point order
+    and code unit order disagree for every key containing a character above
+    the BMP.
+    """
+    try:
+        return sorted(obj.items(), key=lambda kv: kv[0].encode('utf-16-be'))
+    except AttributeError as e:
+        raise CanonicalizationError('object keys must be strings') from e
+    except UnicodeEncodeError as e:
+        raise CanonicalizationError(
+            'object key contains text that is not valid Unicode'
+        ) from e
+
+
+def _quote(value: str) -> str:
+    """Returns the canonical form of a JSON string."""
+    return '"' + _ESCAPE_RE.sub(lambda m: _ESCAPE_MAP[m.group(0)], value) + '"'
+
+
+def _format_number(value: float) -> str:
+    """Formats a float per ECMA-262 7.1.12.1, as RFC 8785 section 3.2.2.3 requires."""
+    if math.isnan(value) or math.isinf(value):
+        raise CanonicalizationError(f'{value} is not a JSON number')
+
+    # Covers -0.0, which ECMAScript renders as "0".
+    if value == 0:
+        return '0'
+
+    if value < 0:
+        return '-' + _format_number(-value)
+
+    # Adapted from the reference implementation; see the module docstring.
+    stringified = str(value)
+
+    exponent_str = ''
+    exponent_value = 0
+    separator = stringified.find('e')
+    if separator > 0:
+        exponent_str = stringified[separator:]
+        if exponent_str[2:3] == '0':
+            # Python pads the exponent to two digits; ECMAScript does not.
+            exponent_str = exponent_str[:2] + exponent_str[3:]
+        stringified = stringified[0:separator]
+        exponent_value = int(exponent_str[1:])
+
+    first = stringified
+    dot = ''
+    last = ''
+    separator = stringified.find('.')
+    if separator > 0:
+        dot = '.'
+        first = stringified[:separator]
+        last = stringified[separator + 1 :]
+
+    if last == '0':
+        # Python writes an integral float as "1.0"; ECMAScript writes "1".
+        dot = ''
+        last = ''
+
+    if 0 < exponent_value < _EXPONENT_EXPANSION_CEILING:
+        # Values up to 1e21 are written out in full rather than in exponential
+        # notation.
+        first += last
+        last = ''
+        dot = ''
+        exponent_str = ''
+        first += '0' * (exponent_value - len(first) + 1)
+    elif _EXPONENT_EXPANSION_FLOOR < exponent_value < 0:
+        # Values down to 1e-7 are written as 0.000... rather than exponentially.
+        last = first + last
+        first = '0'
+        dot = '.'
+        exponent_str = ''
+        last = '0' * (-exponent_value - 1) + last
+
+    return f'{first}{dot}{last}{exponent_str}'
diff --git a/src/a2a/utils/artifact.py b/src/a2a/utils/artifact.py
deleted file mode 100644
index d282b686a..000000000
--- a/src/a2a/utils/artifact.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import uuid
-
-from a2a.types import Artifact, Part, TextPart
-
-
-def new_text_artifact(
-    name: str,
-    text: str,
-    description: str = '',
-) -> Artifact:
-    return Artifact(
-        artifactId=str(uuid.uuid4()),
-        parts=[Part(root=TextPart(text=text))],
-        name=name,
-        description=description,
-    )
diff --git a/src/a2a/utils/constants.py b/src/a2a/utils/constants.py
new file mode 100644
index 000000000..a1b893b10
--- /dev/null
+++ b/src/a2a/utils/constants.py
@@ -0,0 +1,49 @@
+"""Constants for well-known URIs used throughout the A2A Python SDK."""
+
+from enum import Enum
+
+from a2a.types.a2a_pb2 import TaskState
+
+
+AGENT_CARD_WELL_KNOWN_PATH = '/.well-known/agent-card.json'
+DEFAULT_RPC_URL = '/'
+DEFAULT_LIST_TASKS_PAGE_SIZE = 50
+"""Default page size for the `tasks/list` method."""
+
+MAX_LIST_TASKS_PAGE_SIZE = 100
+"""Maximum page size for the `tasks/list` method."""
+
+A2A_JSON_MEDIA_TYPE = 'application/a2a+json'
+"""Media type for HTTP+JSON binding payloads."""
+
+
+class TransportProtocol(str, Enum):
+    """Transport protocol string constants."""
+
+    JSONRPC = 'JSONRPC'
+    HTTP_JSON = 'HTTP+JSON'
+    GRPC = 'GRPC'
+
+
+JSONRPC_PARSE_ERROR_CODE = -32700
+VERSION_HEADER = 'A2A-Version'
+
+PROTOCOL_VERSION_1_0 = '1.0'
+PROTOCOL_VERSION_0_3 = '0.3'
+PROTOCOL_VERSION_CURRENT = PROTOCOL_VERSION_1_0
+
+TERMINAL_TASK_STATES: frozenset[TaskState.ValueType] = frozenset(
+    {
+        TaskState.TASK_STATE_COMPLETED,
+        TaskState.TASK_STATE_CANCELED,
+        TaskState.TASK_STATE_FAILED,
+        TaskState.TASK_STATE_REJECTED,
+    }
+)
+
+INTERRUPTED_TASK_STATES: frozenset[TaskState.ValueType] = frozenset(
+    {
+        TaskState.TASK_STATE_INPUT_REQUIRED,
+        TaskState.TASK_STATE_AUTH_REQUIRED,
+    }
+)
diff --git a/src/a2a/utils/error_handlers.py b/src/a2a/utils/error_handlers.py
new file mode 100644
index 000000000..ef8182940
--- /dev/null
+++ b/src/a2a/utils/error_handlers.py
@@ -0,0 +1,230 @@
+import functools
+import inspect
+import logging
+
+from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from starlette.responses import JSONResponse, Response
+else:
+    try:
+        from starlette.responses import JSONResponse, Response
+    except ImportError:
+        JSONResponse = Any
+        Response = Any
+
+
+from google.protobuf.json_format import MessageToDict, ParseError
+
+from a2a.utils.errors import (
+    A2A_ERROR_MAPPING,
+    A2A_ERROR_REASONS,
+    A2AError,
+    ErrorMapping,
+    InternalError,
+    InvalidParamsError,
+)
+from a2a.utils.proto_utils import validation_errors_to_bad_request
+
+
+logger = logging.getLogger(__name__)
+
+
+ERROR_INFO_TYPE = 'type.googleapis.com/google.rpc.ErrorInfo'
+BAD_REQUEST_TYPE = 'type.googleapis.com/google.rpc.BadRequest'
+A2A_DOMAIN = 'a2a-protocol.org'
+
+
+def _error_info(
+    reason: str, metadata: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Build a single ``google.rpc.ErrorInfo`` typed-detail object."""
+    return {
+        '@type': ERROR_INFO_TYPE,
+        'reason': reason,
+        'domain': A2A_DOMAIN,
+        'metadata': metadata if metadata is not None else {},
+    }
+
+
+def build_error_details(error: A2AError) -> list[dict[str, Any]]:
+    """Build the typed-details array for an :class:`A2AError`.
+
+    Always emits a leading ``google.rpc.ErrorInfo`` carrying the A2A reason
+    and ``error.data`` as ``metadata``. For `InvalidParamsError` whose ``data``
+    contains an ``errors`` list of validation details, also appends
+    a ``google.rpc.BadRequest`` so all transports surface field-level
+    violations identically.
+    """
+    reason = A2A_ERROR_REASONS.get(type(error), 'UNKNOWN_ERROR')
+    metadata = error.data if isinstance(error.data, dict) else {}
+    details: list[dict[str, Any]] = [_error_info(reason, metadata)]
+
+    if (
+        isinstance(error, InvalidParamsError)
+        and isinstance(error.data, dict)
+        and error.data.get('errors')
+    ):
+        bad_request_dict = MessageToDict(
+            validation_errors_to_bad_request(error.data['errors']),
+            preserving_proto_field_name=False,
+        )
+        details.append(
+            {
+                '@type': BAD_REQUEST_TYPE,
+                'fieldViolations': bad_request_dict.get('fieldViolations', []),
+            }
+        )
+
+    return details
+
+
+def _build_error_payload(
+    code: int,
+    status: str,
+    message: str,
+    details: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Helper function to build the JSON error payload."""
+    payload: dict[str, Any] = {
+        'code': code,
+        'status': status,
+        'message': message,
+    }
+    if details:
+        payload['details'] = details
+    return {'error': payload}
+
+
+def build_rest_error_payload(error: Exception) -> dict[str, Any]:
+    """Build a REST error payload dict from an exception.
+
+    Returns:
+        A dict with the error payload in the standard REST error format.
+    """
+    if isinstance(error, A2AError):
+        mapping = A2A_ERROR_MAPPING.get(
+            type(error), ErrorMapping(500, 'INTERNAL', 'INTERNAL_ERROR')
+        )
+        # SECURITY WARNING: Data attached to A2AError.data is serialized
+        # unaltered and exposed publicly to the client in the REST API
+        # response (as ErrorInfo.metadata).
+        return _build_error_payload(
+            code=mapping.http_code,
+            status=mapping.grpc_status,
+            message=getattr(error, 'message', str(error)),
+            details=build_error_details(error),
+        )
+    if isinstance(error, ParseError):
+        return _build_error_payload(
+            code=400,
+            status='INVALID_ARGUMENT',
+            message=str(error),
+            details=[_error_info('INVALID_REQUEST')],
+        )
+    return _build_error_payload(
+        code=500,
+        status='INTERNAL',
+        message='unknown exception',
+    )
+
+
+def _create_error_response(error: Exception) -> Response:
+    """Helper function to create a JSONResponse for an error."""
+    if isinstance(error, A2AError):
+        log_level = (
+            logging.ERROR
+            if isinstance(error, InternalError)
+            else logging.WARNING
+        )
+        logger.log(
+            log_level,
+            "Request error: Code=%s, Message='%s'%s",
+            getattr(error, 'code', 'N/A'),
+            getattr(error, 'message', str(error)),
+            f', Data={error.data}' if error.data else '',
+        )
+    elif isinstance(error, ParseError):
+        logger.warning('Parse error: %s', str(error))
+    else:
+        logger.exception('Unknown error occurred')
+
+    payload = build_rest_error_payload(error)
+    # Extract HTTP status code from the payload
+    http_code = payload.get('error', {}).get('code', 500)
+    return JSONResponse(
+        content=payload,
+        status_code=http_code,
+        media_type='application/json',
+    )
+
+
+def rest_error_handler(
+    func: Callable[..., Awaitable[Response]],
+) -> Callable[..., Awaitable[Response]]:
+    """Decorator to catch A2AError and map it to an appropriate JSONResponse."""
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Response:
+        try:
+            return await func(*args, **kwargs)
+        except Exception as error:  # noqa: BLE001
+            return _create_error_response(error)
+
+    return wrapper
+
+
+def rest_stream_error_handler(
+    func: Callable[..., Coroutine[Any, Any, Any]],
+) -> Callable[..., Coroutine[Any, Any, Any]]:
+    """Decorator to catch A2AError for a streaming method. Maps synchronous errors to JSONResponse and logs streaming errors."""
+
+    def _log_error(error: Exception) -> None:
+        if isinstance(error, A2AError):
+            log_level = (
+                logging.ERROR
+                if isinstance(error, InternalError)
+                else logging.WARNING
+            )
+            logger.log(
+                log_level,
+                "Request error: Code=%s, Message='%s'%s",
+                getattr(error, 'code', 'N/A'),
+                getattr(error, 'message', str(error)),
+                f', Data={error.data}' if error.data else '',
+            )
+        else:
+            logger.exception('Unknown streaming error occurred')
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            response = await func(*args, **kwargs)
+
+            # If the response has an async generator body (like EventSourceResponse),
+            # we must wrap it to catch errors that occur during stream execution.
+            if hasattr(response, 'body_iterator') and inspect.isasyncgen(
+                response.body_iterator
+            ):
+                original_iterator = response.body_iterator
+
+                async def error_catching_iterator() -> AsyncGenerator[
+                    Any, None
+                ]:
+                    try:
+                        async for item in original_iterator:
+                            yield item
+                    except Exception as stream_error:
+                        _log_error(stream_error)
+                        raise stream_error
+
+                response.body_iterator = error_catching_iterator()
+
+        except Exception as e:  # noqa: BLE001
+            return _create_error_response(e)
+        else:
+            return response
+
+    return wrapper
diff --git a/src/a2a/utils/errors.py b/src/a2a/utils/errors.py
index 49cc7dab1..18aa0f58b 100644
--- a/src/a2a/utils/errors.py
+++ b/src/a2a/utils/errors.py
@@ -1,50 +1,217 @@
-from a2a.types import (
-    ContentTypeNotSupportedError,
-    InternalError,
-    InvalidAgentResponseError,
-    InvalidParamsError,
-    InvalidRequestError,
-    JSONParseError,
-    JSONRPCError,
-    MethodNotFoundError,
-    PushNotificationNotSupportedError,
-    TaskNotCancelableError,
-    TaskNotFoundError,
-    UnsupportedOperationError,
-)
-
-
-class A2AServerError(Exception):
-    """Base exception for A2A Server errors."""
-
-
-class MethodNotImplementedError(A2AServerError):
-    """Exception for Unimplemented methods."""
-
-    def __init__(
-        self, message: str = 'This method is not implemented by the server'
-    ):
-        self.message = message
-        super().__init__(f'Not Implemented operation Error: {message}')
-
-
-class ServerError(Exception):
-    def __init__(
-        self,
-        error: (
-            JSONRPCError
-            | JSONParseError
-            | InvalidRequestError
-            | MethodNotFoundError
-            | InvalidParamsError
-            | InternalError
-            | TaskNotFoundError
-            | TaskNotCancelableError
-            | PushNotificationNotSupportedError
-            | UnsupportedOperationError
-            | ContentTypeNotSupportedError
-            | InvalidAgentResponseError
-            | None
-        ),
-    ):
-        self.error = error
+"""Custom exceptions and error types for A2A server-side errors.
+
+This module contains A2A-specific error codes,
+as well as server exception classes.
+"""
+
+from typing import NamedTuple
+
+
+class ErrorMapping(NamedTuple):
+    """Named tuple mapping HTTP status, gRPC status, and reason strings."""
+
+    http_code: int
+    grpc_status: str
+    reason: str
+
+
+class A2AError(Exception):
+    """Base exception for A2A errors."""
+
+    message: str = 'A2A Error'
+    data: dict | None = None
+
+    def __init__(self, message: str | None = None, data: dict | None = None):
+        if message:
+            self.message = message
+        self.data = data
+        super().__init__(self.message)
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation exposing message and data."""
+        return (
+            f'{self.__class__.__name__}('
+            f'message={self.message!r}, '
+            f'data={self.data!r})'
+        )
+
+
+class TaskNotFoundError(A2AError):
+    """Exception raised when a task is not found."""
+
+    message = 'Task not found'
+
+
+class TaskNotCancelableError(A2AError):
+    """Exception raised when a task cannot be canceled."""
+
+    message = 'Task cannot be canceled'
+
+
+class PushNotificationNotSupportedError(A2AError):
+    """Exception raised when push notifications are not supported."""
+
+    message = 'Push Notification is not supported'
+
+
+class UnsupportedOperationError(A2AError):
+    """Exception raised when an operation is not supported."""
+
+    message = 'This operation is not supported'
+
+
+class ContentTypeNotSupportedError(A2AError):
+    """Exception raised when the content type is incompatible."""
+
+    message = 'Incompatible content types'
+
+
+class InternalError(A2AError):
+    """Exception raised for internal server errors."""
+
+    message = 'Internal error'
+
+
+class InvalidAgentResponseError(A2AError):
+    """Exception raised when the agent response is invalid."""
+
+    message = 'Invalid agent response'
+
+
+class ExtendedAgentCardNotConfiguredError(A2AError):
+    """Exception raised when the authenticated extended card is not configured."""
+
+    message = 'Authenticated Extended Card is not configured'
+
+
+class InvalidParamsError(A2AError):
+    """Exception raised when parameters are invalid."""
+
+    message = 'Invalid params'
+
+
+class InvalidRequestError(A2AError):
+    """Exception raised when the request is invalid."""
+
+    message = 'Invalid Request'
+
+
+class MethodNotFoundError(A2AError):
+    """Exception raised when a method is not found."""
+
+    message = 'Method not found'
+
+
+class JSONParseError(A2AError):
+    """Exception raised when invalid JSON was received by the server."""
+
+    message = 'Invalid JSON payload'
+
+
+class ExtensionSupportRequiredError(A2AError):
+    """Exception raised when extension support is required but not present."""
+
+    message = 'Extension support required'
+
+
+class VersionNotSupportedError(A2AError):
+    """Exception raised when the requested version is not supported."""
+
+    message = 'Version not supported'
+
+
+__all__ = [
+    'A2A_ERROR_MAPPING',
+    'A2A_ERROR_REASONS',
+    'A2A_REASON_TO_ERROR',
+    'A2A_REST_ERROR_MAPPING',
+    'JSON_RPC_ERROR_CODE_MAP',
+    'ErrorMapping',
+    'ExtensionSupportRequiredError',
+    'InternalError',
+    'InvalidAgentResponseError',
+    'InvalidParamsError',
+    'InvalidRequestError',
+    'JSONParseError',
+    'MethodNotFoundError',
+    'PushNotificationNotSupportedError',
+    'TaskNotCancelableError',
+    'TaskNotFoundError',
+    'UnsupportedOperationError',
+    'VersionNotSupportedError',
+]
+
+
+JSON_RPC_ERROR_CODE_MAP: dict[type[A2AError], int] = {
+    TaskNotFoundError: -32001,
+    TaskNotCancelableError: -32002,
+    PushNotificationNotSupportedError: -32003,
+    UnsupportedOperationError: -32004,
+    ContentTypeNotSupportedError: -32005,
+    InvalidAgentResponseError: -32006,
+    ExtendedAgentCardNotConfiguredError: -32007,
+    ExtensionSupportRequiredError: -32008,
+    VersionNotSupportedError: -32009,
+    InvalidParamsError: -32602,
+    InvalidRequestError: -32600,
+    MethodNotFoundError: -32601,
+    InternalError: -32603,
+    JSONParseError: -32700,
+}
+
+
+A2A_ERROR_MAPPING: dict[type[A2AError], ErrorMapping] = {
+    TaskNotFoundError: ErrorMapping(404, 'NOT_FOUND', 'TASK_NOT_FOUND'),
+    TaskNotCancelableError: ErrorMapping(
+        400, 'FAILED_PRECONDITION', 'TASK_NOT_CANCELABLE'
+    ),
+    PushNotificationNotSupportedError: ErrorMapping(
+        400,
+        'FAILED_PRECONDITION',
+        'PUSH_NOTIFICATION_NOT_SUPPORTED',
+    ),
+    UnsupportedOperationError: ErrorMapping(
+        400, 'FAILED_PRECONDITION', 'UNSUPPORTED_OPERATION'
+    ),
+    ContentTypeNotSupportedError: ErrorMapping(
+        400,
+        'INVALID_ARGUMENT',
+        'CONTENT_TYPE_NOT_SUPPORTED',
+    ),
+    InvalidAgentResponseError: ErrorMapping(
+        500, 'INTERNAL', 'INVALID_AGENT_RESPONSE'
+    ),
+    ExtendedAgentCardNotConfiguredError: ErrorMapping(
+        400,
+        'FAILED_PRECONDITION',
+        'EXTENDED_AGENT_CARD_NOT_CONFIGURED',
+    ),
+    ExtensionSupportRequiredError: ErrorMapping(
+        400,
+        'FAILED_PRECONDITION',
+        'EXTENSION_SUPPORT_REQUIRED',
+    ),
+    VersionNotSupportedError: ErrorMapping(
+        400, 'FAILED_PRECONDITION', 'VERSION_NOT_SUPPORTED'
+    ),
+    InvalidParamsError: ErrorMapping(400, 'INVALID_ARGUMENT', 'INVALID_PARAMS'),
+    InvalidRequestError: ErrorMapping(
+        400, 'INVALID_ARGUMENT', 'INVALID_REQUEST'
+    ),
+    MethodNotFoundError: ErrorMapping(404, 'NOT_FOUND', 'METHOD_NOT_FOUND'),
+    InternalError: ErrorMapping(500, 'INTERNAL', 'INTERNAL_ERROR'),
+}
+
+
+# Deprecated alias kept for backwards compatibility; remove in the next
+# major version.
+A2A_REST_ERROR_MAPPING = A2A_ERROR_MAPPING
+
+
+A2A_ERROR_REASONS = {
+    cls: mapping.reason for cls, mapping in A2A_ERROR_MAPPING.items()
+}
+
+A2A_REASON_TO_ERROR = {
+    mapping.reason: cls for cls, mapping in A2A_ERROR_MAPPING.items()
+}
diff --git a/src/a2a/utils/grpc_status.py b/src/a2a/utils/grpc_status.py
new file mode 100644
index 000000000..5f0074f24
--- /dev/null
+++ b/src/a2a/utils/grpc_status.py
@@ -0,0 +1,71 @@
+import logging
+
+from typing import Any, NamedTuple
+
+
+try:
+    import grpc  # type: ignore[reportMissingModuleSource]
+except ImportError:
+    grpc = None  # type: ignore
+
+from google.rpc import status_pb2  # type: ignore[reportMissingModuleSource]
+
+
+logger = logging.getLogger(__name__)
+
+GRPC_STATUS_DETAILS_BIN_KEY = 'grpc-status-details-bin'
+
+
+class GrpcStatus(NamedTuple):
+    """Represents the gRPC status code, details, and trailing metadata."""
+
+    code: Any
+    details: str
+    trailing_metadata: tuple
+
+
+def status_to_grpc(status: status_pb2.Status) -> GrpcStatus:
+    """Converts a google.rpc.status.Status message into its gRPC components."""
+    if grpc is None:
+        raise ImportError(
+            'gRPC is not installed. Install with: pip install a2a-sdk[grpc]'
+        )
+    for x in grpc.StatusCode:
+        if x.value[0] == status.code:
+            grpc_code = x
+            break
+    else:
+        raise ValueError(f'Invalid status code {status.code}')
+
+    bin_data = status.SerializeToString()
+    metadata = ((GRPC_STATUS_DETAILS_BIN_KEY, bin_data),)
+
+    return GrpcStatus(grpc_code, status.message, metadata)
+
+
+def status_from_call(call: Any) -> status_pb2.Status | None:
+    """Extracts a google.rpc.status.Status message from a grpc.Call instance."""
+    if grpc is None:
+        raise ImportError(
+            'gRPC is not installed. Install with: pip install a2a-sdk[grpc]'
+        )
+    if not hasattr(call, 'trailing_metadata'):
+        return None
+    trailing_metadata = call.trailing_metadata()
+    if not trailing_metadata:
+        return None
+    for k, v in trailing_metadata:
+        if k == GRPC_STATUS_DETAILS_BIN_KEY:
+            status = status_pb2.Status()
+            status.ParseFromString(v)
+
+            if call.code().value[0] != status.code:
+                raise ValueError(
+                    f'Mismatched status code: proto={status.code}, call={call.code()}'
+                )
+            if call.details() != status.message:
+                raise ValueError(
+                    f'Mismatched status message: proto={status.message!r}, call={call.details()!r}'
+                )
+            return status
+    return None
diff --git a/src/a2a/utils/helpers.py b/src/a2a/utils/helpers.py
deleted file mode 100644
index 2b5d2fe50..000000000
--- a/src/a2a/utils/helpers.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import logging
-
-from uuid import uuid4
-
-from a2a.types import (
-    Artifact,
-    MessageSendParams,
-    Part,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskState,
-    TaskStatus,
-    TextPart,
-)
-from a2a.utils.errors import ServerError, UnsupportedOperationError
-
-
-logger = logging.getLogger(__name__)
-
-
-def create_task_obj(message_send_params: MessageSendParams) -> Task:
-    """Create a new task object from message send params."""
-    if not message_send_params.message.contextId:
-        message_send_params.message.contextId = str(uuid4())
-
-    return Task(
-        id=str(uuid4()),
-        contextId=message_send_params.message.contextId,
-        status=TaskStatus(state=TaskState.submitted),
-        history=[message_send_params.message],
-    )
-
-
-def append_artifact_to_task(task: Task, event: TaskArtifactUpdateEvent) -> None:
-    """Helper method for updating Task with new artifact data."""
-    if not task.artifacts:
-        task.artifacts = []
-
-    new_artifact_data: Artifact = event.artifact
-    artifact_id: str = new_artifact_data.artifactId
-    append_parts: bool = event.append or False
-
-    existing_artifact: Artifact | None = None
-    existing_artifact_list_index: int | None = None
-
-    # Find existing artifact by its id
-    for i, art in enumerate(task.artifacts):
-        if hasattr(art, 'artifactId') and art.artifactId == artifact_id:
-            existing_artifact = art
-            existing_artifact_list_index = i
-            break
-
-    if not append_parts:
-        # This represents the first chunk for this artifact index.
-        if existing_artifact_list_index is not None:
-            # Replace the existing artifact entirely with the new data
-            logger.debug(
-                f'Replacing artifact at id {artifact_id} for task {task.id}'
-            )
-            task.artifacts[existing_artifact_list_index] = new_artifact_data
-        else:
-            # Append the new artifact since no artifact with this index exists yet
-            logger.debug(
-                f'Adding new artifact with id {artifact_id} for task {task.id}'
-            )
-            task.artifacts.append(new_artifact_data)
-    elif existing_artifact:
-        # Append new parts to the existing artifact's part list
-        logger.debug(
-            f'Appending parts to artifact id {artifact_id} for task {task.id}'
-        )
-        existing_artifact.parts.extend(new_artifact_data.parts)
-    else:
-        # We received a chunk to append, but we don't have an existing artifact.
-        # we will ignore this chunk
-        logger.warning(
-            f'Received append=True for nonexistent artifact index {artifact_id} in task {task.id}. Ignoring chunk.'
-        )
-
-
-def build_text_artifact(text: str, artifact_id: str) -> Artifact:
-    """Helper to convert agent text to artifact."""
-    text_part = TextPart(text=text)
-    part = Part(root=text_part)
-    return Artifact(parts=[part], artifactId=artifact_id)
-
-
-def validate(expression, error_message=None):
-    """Decorator that validates if the given expression evaluates to True."""
-
-    def decorator(function):
-        def wrapper(self, *args, **kwargs):
-            if not expression(self):
-                if not error_message:
-                    message = str(expression)
-                logger.error(f'Unsupported Operation: {error_message}')
-                raise ServerError(
-                    UnsupportedOperationError(message=error_message)
-                )
-            return function(self, *args, **kwargs)
-
-        return wrapper
-
-    return decorator
diff --git a/src/a2a/utils/input_mode_validator.py b/src/a2a/utils/input_mode_validator.py
new file mode 100644
index 000000000..8901409d1
--- /dev/null
+++ b/src/a2a/utils/input_mode_validator.py
@@ -0,0 +1,47 @@
+"""Shared policy for checking message parts against an agent's declared input modes."""
+
+from a2a.types.a2a_pb2 import AgentCard, Message
+from a2a.utils.errors import ContentTypeNotSupportedError
+
+
+def validate_input_modes(message: Message, agent_card: AgentCard) -> None:
+    """Rejects parts whose media type the agent card does not declare.
+
+    The allowed set is the union of `default_input_modes` and every skill's
+    `input_modes`, which may widen it: a skill's `input_modes` overrides the
+    card default for that skill. A request does not name the skill that will
+    serve it, so the union is the most that can be decided here -- anything
+    outside it is supported by no skill and cannot be served, while a media
+    type inside it may still reach a skill that does not take it, which only
+    that skill can answer.
+
+    A card declaring no input modes anywhere accepts everything: an empty
+    union is an absent declaration, not an empty allowlist. `media_type` is
+    a proto3 string, so a part that omits it arrives as `''` and is likewise
+    not checked -- only a media type the client actually stated can
+    contradict the card.
+
+    Media types are compared on type and subtype alone, ignoring case
+    (RFC 2045 section 5.1) and parameters, so `Text/Plain; charset=utf-8`
+    matches a card that declares `text/plain`.
+    """
+    modes = set(agent_card.default_input_modes)
+    for skill in agent_card.skills:
+        modes.update(skill.input_modes)
+    declared = {_essence(mode) for mode in modes}
+    if not declared:
+        return
+
+    for part in message.parts:
+        if part.media_type and _essence(part.media_type) not in declared:
+            raise ContentTypeNotSupportedError(
+                message=(
+                    f'Media type {part.media_type} is not supported. '
+                    f'Supported input modes: {", ".join(sorted(modes))}'
+                )
+            )
+
+
+def _essence(media_type: str) -> str:
+    """Returns `type/subtype` in lower case, without parameters."""
+    return media_type.split(';', 1)[0].strip().lower()
diff --git a/src/a2a/utils/json_utils.py b/src/a2a/utils/json_utils.py
new file mode 100644
index 000000000..304bb24a6
--- /dev/null
+++ b/src/a2a/utils/json_utils.py
@@ -0,0 +1,19 @@
+"""JSON serialization helpers for the A2A Python SDK."""
+
+import json
+
+from typing import Any
+
+
+def dumps(obj: Any) -> str:
+    r"""Serialize ``obj`` to a JSON-formatted ``str`` with UTF-8 defaults.
+
+    Use this in SSE/streaming code paths where payloads are serialized
+    manually before being written to the wire. Unary HTTP responses do
+    not need it because Starlette's ``JSONResponse.render`` already calls
+    ``json.dumps(content, ensure_ascii=False, ...)`` internally; this
+    helper makes the streaming paths behave identically so non-ASCII
+    characters (CJK, emoji, etc.) reach clients as raw UTF-8 rather than
+    escape sequences.
+    """
+    return json.dumps(obj, ensure_ascii=False)
diff --git a/src/a2a/utils/message.py b/src/a2a/utils/message.py
deleted file mode 100644
index cf153a79c..000000000
--- a/src/a2a/utils/message.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import uuid
-
-from a2a.types import (
-    Message,
-    Part,
-    Role,
-    TextPart,
-)
-
-
-def new_agent_text_message(
-    text: str, context_id: str | None = None, task_id: str | None = None
-) -> Message:
-    """Creates a new agent text message."""
-    return Message(
-        role=Role.agent,
-        parts=[Part(root=TextPart(text=text))],
-        messageId=str(uuid.uuid4()),
-        taskId=task_id,
-        contextId=context_id,
-    )
-
-
-def get_text_parts(parts: list[Part]) -> list[str]:
-    """Return all text parts from a list of parts."""
-    return [part.root.text for part in parts if isinstance(part.root, TextPart)]
-
-
-def get_message_text(message: Message, delimiter='\n') -> str:
-    return delimiter.join(get_text_parts(message.parts))
diff --git a/src/a2a/utils/proto_utils.py b/src/a2a/utils/proto_utils.py
new file mode 100644
index 000000000..9a1c3761c
--- /dev/null
+++ b/src/a2a/utils/proto_utils.py
@@ -0,0 +1,422 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utilities for working with proto types.
+
+This module provides helper functions for common proto type operations.
+"""
+
+import logging
+
+from typing import TYPE_CHECKING, Any, TypeVar, TypedDict, cast
+
+from google.api.field_behavior_pb2 import FieldBehavior, field_behavior
+from google.protobuf.descriptor import FieldDescriptor
+from google.protobuf.json_format import Parse, ParseDict, ParseError
+from google.protobuf.message import Message as ProtobufMessage
+from google.rpc import error_details_pb2
+
+from a2a.utils.errors import InvalidParamsError
+
+
+if TYPE_CHECKING:
+    from starlette.datastructures import QueryParams
+else:
+    try:
+        from starlette.datastructures import QueryParams
+    except ImportError:
+        QueryParams = Any
+
+from a2a.types.a2a_pb2 import (
+    Message,
+    StreamResponse,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskStatusUpdateEvent,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# Define Event type locally to avoid circular imports
+Event = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent
+
+_MessageT = TypeVar('_MessageT', bound=ProtobufMessage)
+
+
+def parse_lenient(
+    data: dict[str, Any] | str | bytes, message: _MessageT
+) -> _MessageT:
+    """Parses ProtoJSON into message, ignoring unrecognized fields.
+
+    Args:
+        data: A decoded JSON object, or raw ProtoJSON text/bytes.
+        message: The message to parse into. Mutated in place and returned.
+
+    Returns:
+        The parsed message.
+
+    Raises:
+        ParseError: If the data is not valid ProtoJSON, including bytes that
+            are not valid UTF-8 and decoded values that are not objects.
+    """
+    if isinstance(data, bytes):
+        try:
+            data = data.decode('utf-8')
+        except UnicodeDecodeError as e:
+            raise ParseError(f'Failed to load JSON: {e}.') from e
+    if isinstance(data, str):
+        return Parse(data, message, ignore_unknown_fields=True)
+    # A message is a JSON object. With ignore_unknown_fields, ParseDict reads
+    # an empty list as an empty message (it iterates the value as if it were
+    # the object's keys), and raises TypeError for null or a number.
+    if not isinstance(data, dict):
+        raise ParseError(
+            f'Expected a JSON object for {message.DESCRIPTOR.name}, '
+            f'got {type(data).__name__}.'
+        )
+    return ParseDict(data, message, ignore_unknown_fields=True)
+
+
+def to_stream_response(event: Event) -> StreamResponse:
+    """Convert internal Event to StreamResponse proto.
+
+    Args:
+        event: The event (Task, Message, TaskStatusUpdateEvent, TaskArtifactUpdateEvent)
+
+    Returns:
+        A StreamResponse proto with the appropriate field set.
+    """
+    response = StreamResponse()
+    if isinstance(event, Task):
+        response.task.CopyFrom(event)
+    elif isinstance(event, Message):
+        response.message.CopyFrom(event)
+    elif isinstance(event, TaskStatusUpdateEvent):
+        response.status_update.CopyFrom(event)
+    elif isinstance(event, TaskArtifactUpdateEvent):
+        response.artifact_update.CopyFrom(event)
+    return response
+
+
+def make_dict_serializable(value: Any) -> Any:
+    """Dict pre-processing utility: converts non-serializable values to serializable form.
+
+    Use this when you want to normalize a dictionary before dict->Struct conversion.
+
+    Args:
+        value: The value to convert.
+
+    Returns:
+        A serializable value.
+    """
+    if isinstance(value, str | int | float | bool) or value is None:
+        return value
+    if isinstance(value, dict):
+        return {k: make_dict_serializable(v) for k, v in value.items()}
+    if isinstance(value, list | tuple):
+        return [make_dict_serializable(item) for item in value]
+    return str(value)
+
+
+def normalize_large_integers_to_strings(
+    value: Any, max_safe_digits: int = 15
+) -> Any:
+    """Integer preprocessing utility: converts large integers to strings.
+
+    Use this when you want to convert large integers to strings considering
+    JavaScript's MAX_SAFE_INTEGER (2^53 - 1) limitation.
+
+    Args:
+        value: The value to convert.
+        max_safe_digits: Maximum safe integer digits (default: 15).
+
+    Returns:
+        A normalized value.
+    """
+    max_safe_int = 10**max_safe_digits - 1
+
+    def _normalize(item: Any) -> Any:
+        if isinstance(item, int) and abs(item) > max_safe_int:
+            return str(item)
+        if isinstance(item, dict):
+            return {k: _normalize(v) for k, v in item.items()}
+        if isinstance(item, list | tuple):
+            return [_normalize(i) for i in item]
+        return item
+
+    return _normalize(value)
+
+
+def parse_string_integers_in_dict(value: Any, max_safe_digits: int = 15) -> Any:
+    """String post-processing utility: converts large integer strings back to integers.
+
+    Use this when you want to restore large integer strings to integers
+    after Struct->dict conversion.
+
+    Args:
+        value: The value to convert.
+        max_safe_digits: Maximum safe integer digits (default: 15).
+
+    Returns:
+        A parsed value.
+    """
+    if isinstance(value, dict):
+        return {
+            k: parse_string_integers_in_dict(v, max_safe_digits)
+            for k, v in value.items()
+        }
+    if isinstance(value, list | tuple):
+        return [
+            parse_string_integers_in_dict(item, max_safe_digits)
+            for item in value
+        ]
+    if isinstance(value, str):
+        # Handle potential negative numbers.
+        stripped_value = value.lstrip('-')
+        if stripped_value.isdigit() and len(stripped_value) > max_safe_digits:
+            return int(value)
+    return value
+
+
+def _field_is_repeated(field: FieldDescriptor) -> bool:
+    """protobuf>=6.31.0 exposes `is_repeated`; older (floor >=5.29.5) does not."""
+    is_repeated = getattr(field, 'is_repeated', None)
+    if is_repeated is not None:
+        return is_repeated
+    # protobuf 7 removed `label`; only reached on the <6.31 fallback path.
+    return getattr(field, 'label', None) == FieldDescriptor.LABEL_REPEATED
+
+
+def parse_params(params: QueryParams, message: ProtobufMessage) -> None:
+    """Converts REST query parameters back into a Protobuf message.
+
+    Handles A2A-specific pre-processing before calling ParseDict:
+    - Booleans: 'true'/'false' -> True/False
+    - Repeated: Supports BOTH repeated keys and comma-separated values.
+    - Others: Handles string->enum/timestamp/number conversion via ParseDict.
+
+    See Also:
+        https://a2a-protocol.org/latest/specification/#115-query-parameter-naming-for-request-parameters
+    """
+    descriptor = message.DESCRIPTOR
+    fields = {
+        f.camelcase_name: cast('FieldDescriptor', f) for f in descriptor.fields
+    }
+    processed: dict[str, Any] = {}
+
+    keys = params.keys()
+
+    for k in keys:
+        if k not in fields:
+            continue
+
+        field = fields[k]
+        v_list = params.getlist(k)
+
+        if _field_is_repeated(field):
+            accumulated: list[Any] = []
+            for v in v_list:
+                if not v:
+                    continue
+                if isinstance(v, str):
+                    accumulated.extend([x for x in v.split(',') if x])
+                else:
+                    accumulated.append(v)
+            processed[k] = accumulated
+        else:
+            # For non-repeated fields, the last one wins.
+            raw_val = v_list[-1]
+            if raw_val is not None:
+                parsed_val: Any = raw_val
+                if field.type == field.TYPE_BOOL and isinstance(raw_val, str):
+                    if raw_val.lower() not in ('true', 'false'):
+                        raise ParseError(
+                            f'Invalid boolean query parameter {k}: expected "true" or "false".'
+                        )
+                    parsed_val = raw_val.lower() == 'true'
+                processed[k] = parsed_val
+
+    ParseDict(processed, message, ignore_unknown_fields=True)
+
+
+class ValidationDetail(TypedDict):
+    """Structured validation error detail."""
+
+    field: str
+    message: str
+
+
+def _check_required_field_violation(
+    msg: ProtobufMessage, field: FieldDescriptor
+) -> ValidationDetail | None:
+    """Check if a required field is missing or invalid."""
+    val = getattr(msg, field.name)
+    if _field_is_repeated(field):
+        if not val:
+            return ValidationDetail(
+                field=field.name,
+                message='Field must contain at least one element.',
+            )
+    elif field.has_presence:
+        if not msg.HasField(field.name):
+            return ValidationDetail(
+                field=field.name, message='Field is required.'
+            )
+    elif val == field.default_value:
+        return ValidationDetail(field=field.name, message='Field is required.')
+    return None
+
+
+def _append_nested_errors(
+    errors: list[ValidationDetail],
+    prefix: str,
+    sub_errs: list[ValidationDetail],
+) -> None:
+    """Format nested validation errors and append to errors list."""
+    for sub in sub_errs:
+        sub_field = sub['field']
+        errors.append(
+            ValidationDetail(
+                field=f'{prefix}.{sub_field}' if sub_field else prefix,
+                message=sub['message'],
+            )
+        )
+
+
+def _recurse_validation(
+    msg: ProtobufMessage, field: FieldDescriptor
+) -> list[ValidationDetail]:
+    """Recurse validation for nested messages and map fields."""
+    errors: list[ValidationDetail] = []
+    if field.type != FieldDescriptor.TYPE_MESSAGE:
+        return errors
+
+    val = getattr(msg, field.name)
+    if not _field_is_repeated(field):
+        if msg.HasField(field.name):
+            sub_errs = _validate_proto_required_fields_internal(val)
+            _append_nested_errors(errors, field.name, sub_errs)
+    elif (
+        field.message_type is not None
+        and field.message_type.GetOptions().map_entry
+    ):
+        for k, v in val.items():
+            if isinstance(v, ProtobufMessage):
+                sub_errs = _validate_proto_required_fields_internal(v)
+                _append_nested_errors(errors, f'{field.name}[{k}]', sub_errs)
+    else:
+        for i, item in enumerate(val):
+            sub_errs = _validate_proto_required_fields_internal(item)
+            _append_nested_errors(errors, f'{field.name}[{i}]', sub_errs)
+    return errors
+
+
+def _validate_proto_required_fields_internal(
+    msg: ProtobufMessage,
+) -> list[ValidationDetail]:
+    """Internal validation that returns a list of error dictionaries."""
+    desc = msg.DESCRIPTOR
+    errors: list[ValidationDetail] = []
+
+    for raw_field in desc.fields:
+        # `desc.fields` is typed as a union of the pure-Python and C-extension
+        # FieldDescriptor; narrow to the canonical one for the helpers below.
+        field = cast('FieldDescriptor', raw_field)
+        options = field.GetOptions()
+        if FieldBehavior.REQUIRED in options.Extensions[field_behavior]:  # type: ignore[index]  # ty: ignore[invalid-argument-type]
+            violation = _check_required_field_violation(msg, field)
+            if violation:
+                errors.append(violation)
+        errors.extend(_recurse_validation(msg, field))
+    return errors
+
+
+def validate_proto_required_fields(msg: ProtobufMessage) -> None:
+    """Validate that all fields marked as REQUIRED are present on the proto message.
+
+    Args:
+        msg: The Protobuf message to validate.
+
+    Raises:
+        InvalidParamsError: If a required field is missing or empty.
+    """
+    errors = _validate_proto_required_fields_internal(msg)
+
+    if errors:
+        raise InvalidParamsError(
+            message='Validation failed', data={'errors': errors}
+        )
+
+
+_SPEC_FIELD_PRESENCE_URL = (
+    'https://a2a-protocol.org/latest/specification/'
+    '#57-field-presence-and-optionality'
+)
+
+
+def warn_on_missing_required_fields(msg: ProtobufMessage, source: str) -> bool:
+    """Log a warning if fields marked as REQUIRED are missing or empty.
+
+    Unlike `validate_proto_required_fields`, this never raises, so it can
+    surface spec violations without breaking callers that currently rely on
+    non-compliant messages.
+
+    Args:
+        msg: The Protobuf message to check.
+        source: Where the message was passed in, used in the log message.
+
+    Returns:
+        True if every REQUIRED field is set, False otherwise. Objects that
+        are not Protobuf messages (for example test doubles) are not checked.
+    """
+    if not isinstance(msg, ProtobufMessage):
+        return True
+    errors = _validate_proto_required_fields_internal(msg)
+    if not errors:
+        return True
+    logger.warning(
+        '%s %s is not spec-compliant - REQUIRED fields missing or empty: '
+        '%s. This is allowed and does not raise, but it may not verify or '
+        'interoperate across SDKs and could be rejected in a future major '
+        'release. See %s',
+        source,
+        msg.DESCRIPTOR.name,
+        ', '.join(err['field'] for err in errors),
+        _SPEC_FIELD_PRESENCE_URL,
+    )
+    return False
+
+
+def validation_errors_to_bad_request(
+    errors: list[ValidationDetail],
+) -> error_details_pb2.BadRequest:
+    """Convert validation error details to a gRPC BadRequest proto."""
+    bad_request = error_details_pb2.BadRequest()
+    for err in errors:
+        violation = bad_request.field_violations.add()
+        violation.field = err['field']
+        violation.description = err['message']
+    return bad_request
+
+
+def bad_request_to_validation_errors(
+    bad_request: error_details_pb2.BadRequest,
+) -> list[ValidationDetail]:
+    """Convert a gRPC BadRequest proto to validation error details."""
+    return [
+        ValidationDetail(field=v.field, message=v.description)
+        for v in bad_request.field_violations
+    ]
diff --git a/src/a2a/utils/push_url_validator.py b/src/a2a/utils/push_url_validator.py
new file mode 100644
index 000000000..97240bde0
--- /dev/null
+++ b/src/a2a/utils/push_url_validator.py
@@ -0,0 +1,92 @@
+"""Shared policy for screening client-supplied push-notification URLs."""
+
+import asyncio
+import ipaddress
+import logging
+import socket
+import urllib.parse
+
+
+logger = logging.getLogger(__name__)
+
+
+def _ip_is_blocked(ip_str: str) -> bool:
+    """Whether an address is not a public unicast destination.
+
+    RFC 6598 shared address space (100.64.0.0/10) is not public.
+    ``ipaddress`` leaves ``is_private`` false for it and ``is_global``
+    false as well, so ``not is_global`` still rejects it. An IPv4-mapped
+    IPv6 address is judged as the IPv4 address inside it.
+    """
+    try:
+        addr = ipaddress.ip_address(ip_str.split('%', maxsplit=1)[0])
+    except ValueError:
+        return True
+    mapped = getattr(addr, 'ipv4_mapped', None)
+    if mapped is not None:
+        addr = mapped
+    return (
+        not addr.is_global
+        or addr.is_loopback
+        or addr.is_link_local
+        or addr.is_multicast
+        or addr.is_reserved
+        or addr.is_unspecified
+    )
+
+
+async def validate_push_notification_url(url: str) -> bool:
+    """Return True if a push-notification URL is safe to fetch.
+
+    Blocks non-HTTP(S) schemes and hosts that resolve to loopback,
+    link-local, private, shared (100.64.0.0/10), reserved, multicast,
+    or unspecified addresses (e.g. 169.254.169.254 cloud metadata,
+    internal services). A host that cannot be resolved is rejected:
+    the POST would fail anyway, and failing closed avoids treating
+    resolution errors as a bypass.
+
+    IPv4-mapped IPv6 forms are judged as the IPv4 address they carry,
+    so the private, shared, and loopback checks apply to that address.
+
+    Uses the running event-loop resolver so request handlers and the
+    sender stay non-blocking. Deployments can pass this function as
+    ``push_url_validator`` on ``DefaultRequestHandler`` /
+    ``DefaultRequestHandlerV2`` / ``BasePushNotificationSender``.
+    The default on those constructors is ``None`` (no library
+    screening).
+    """
+    try:
+        parsed = urllib.parse.urlparse(url)
+        explicit_port = parsed.port
+    except ValueError:
+        logger.warning('Push-notification URL is unparseable: %s', url)
+        return False
+    if parsed.scheme not in ('http', 'https'):
+        logger.warning(
+            'Push-notification URL scheme %r is not http/https: %s',
+            parsed.scheme,
+            url,
+        )
+        return False
+    host = parsed.hostname
+    if not host:
+        logger.warning('Push-notification URL has no hostname: %s', url)
+        return False
+    port = explicit_port or (443 if parsed.scheme == 'https' else 80)
+    try:
+        loop = asyncio.get_running_loop()
+        infos = await loop.getaddrinfo(host, port, type=socket.SOCK_STREAM)
+    except OSError:
+        logger.warning(
+            'Push-notification host %r could not be resolved: %s', host, url
+        )
+        return False
+    for info in infos:
+        if _ip_is_blocked(str(info[4][0])):
+            logger.warning(
+                'Push-notification host %r resolves to a non-public address: %s',
+                host,
+                url,
+            )
+            return False
+    return True
diff --git a/src/a2a/utils/signing.py b/src/a2a/utils/signing.py
new file mode 100644
index 000000000..da9070c86
--- /dev/null
+++ b/src/a2a/utils/signing.py
@@ -0,0 +1,221 @@
+import binascii
+import json
+
+from collections.abc import Callable
+from typing import Any, TypedDict
+
+from google.protobuf.json_format import MessageToDict
+
+
+try:
+    import jwt
+
+    from jwt import api_jws
+    from jwt.api_jwk import PyJWK
+    from jwt.exceptions import PyJWTError
+    from jwt.utils import base64url_decode, base64url_encode
+except ImportError as e:
+    raise ImportError(
+        'A2A Signing requires PyJWT to be installed. '
+        'Install with: '
+        "'pip install a2a-sdk[signing]'"
+    ) from e
+
+from a2a.types import AgentCard, AgentCardSignature
+from a2a.utils._jcs import MAX_DEPTH, CanonicalizationError, canonicalize
+from a2a.utils.proto_utils import warn_on_missing_required_fields
+
+
+class SignatureVerificationError(Exception):
+    """Base exception for signature verification errors."""
+
+
+class NoSignatureError(SignatureVerificationError):
+    """Exception raised when no signature is found on an AgentCard."""
+
+
+class InvalidSignaturesError(SignatureVerificationError):
+    """Exception raised when all signatures are invalid."""
+
+
+class ProtectedHeader(TypedDict):
+    """Protected header parameters for JWS (JSON Web Signature)."""
+
+    kid: str
+    """ Key identifier. """
+    alg: str | None
+    """ Algorithm used for signing. """
+    jku: str | None
+    """ JSON Web Key Set URL. """
+    typ: str | None
+    """ Token type.
+
+    Best practice: SHOULD be "JOSE" for JWS tokens.
+    """
+
+
+def create_agent_card_signer(
+    signing_key: PyJWK | str | bytes,
+    protected_header: ProtectedHeader,
+    header: dict[str, Any] | None = None,
+) -> Callable[[AgentCard], AgentCard]:
+    """Creates a function that signs an AgentCard and adds the signature.
+
+    Args:
+        signing_key: The private key for signing.
+        protected_header: The protected header parameters.
+        header: Unprotected header parameters.
+
+    Returns:
+        A callable that takes an AgentCard and returns the modified AgentCard with a signature.
+    """
+
+    def agent_card_signer(agent_card: AgentCard) -> AgentCard:
+        """Signs agent card."""
+        canonical_payload = _canonicalize_agent_card(agent_card)
+
+        # The JWS payload has to be the canonical bytes themselves. Handing a
+        # parsed dict to the JWT layer would let PyJWT re-serialize it with its
+        # own json.dumps, which escapes non-ASCII, so the bytes signed would
+        # differ from the bytes the verifier canonicalizes and checks.
+        jws_string = api_jws.encode(
+            payload=canonical_payload.encode('utf-8'),
+            key=signing_key,
+            algorithm=protected_header.get('alg', 'HS256'),
+            headers=dict(protected_header),
+        )
+
+        # The result is a compact serialization: HEADER.PAYLOAD.SIGNATURE
+        protected, _, signature = jws_string.split('.')
+
+        agent_card_signature = AgentCardSignature(
+            header=header,
+            protected=protected,
+            signature=signature,
+        )
+
+        agent_card.signatures.append(agent_card_signature)
+        return agent_card
+
+    return agent_card_signer
+
+
+def create_signature_verifier(
+    key_provider: Callable[[str | None, str | None], PyJWK | str | bytes],
+    algorithms: list[str],
+) -> Callable[[AgentCard], None]:
+    """Creates a function that verifies the signatures on an AgentCard.
+
+    The verifier succeeds if at least one signature is valid. Otherwise, it raises an error.
+
+    Args:
+        key_provider: A callable that accepts a key ID (kid) and a JWK Set URL (jku) and returns the verification key.
+                      This function is responsible for fetching the correct key for a given signature.
+        algorithms: A list of acceptable algorithms (e.g., ['ES256', 'RS256']) for verification used to prevent algorithm confusion attacks.
+
+    Returns:
+        A function that takes an AgentCard as input, and raises an error if none of the signatures are valid.
+    """
+
+    def signature_verifier(
+        agent_card: AgentCard,
+    ) -> None:
+        """Verifies agent card signatures."""
+        if not agent_card.signatures:
+            raise NoSignatureError('AgentCard has no signatures to verify.')
+
+        # The canonical form does not depend on which signature is being
+        # checked, so it is computed once. A card with no canonical form has no
+        # verifiable signature, and reporting that as InvalidSignaturesError
+        # keeps every failure on this path a SignatureVerificationError.
+        try:
+            canonical_payload = _canonicalize_agent_card(agent_card)
+        except CanonicalizationError as e:
+            raise InvalidSignaturesError(
+                'AgentCard cannot be canonicalized for verification'
+            ) from e
+        encoded_payload = base64url_encode(
+            canonical_payload.encode('utf-8')
+        ).decode('utf-8')
+
+        for agent_card_signature in agent_card.signatures:
+            try:
+                # get verification key
+                protected_header_json = base64url_decode(
+                    agent_card_signature.protected.encode('utf-8')
+                ).decode('utf-8')
+                protected_header = json.loads(protected_header_json)
+            except (binascii.Error, UnicodeDecodeError, json.JSONDecodeError):
+                continue
+
+            if not isinstance(protected_header, dict):
+                continue
+
+            try:
+                kid = protected_header.get('kid')
+                jku = protected_header.get('jku')
+                verification_key = key_provider(kid, jku)
+
+                token = f'{agent_card_signature.protected}.{encoded_payload}.{agent_card_signature.signature}'
+                jwt.decode(
+                    jwt=token,
+                    key=verification_key,
+                    algorithms=algorithms,
+                )
+                # Found a valid signature, exit the loop and function
+                break
+            except PyJWTError:
+                continue
+        else:
+            # This block runs only if the loop completes without a break
+            raise InvalidSignaturesError('No valid signature found')
+
+    return signature_verifier
+
+
+def _clean_empty(d: Any, depth: int = 1) -> Any:
+    """Recursively remove empty strings, lists and dicts from a dictionary.
+
+    Depth is bounded for the same reason canonicalization is: nesting reaches
+    this function from `AgentExtension.params`, and without the bound a deeply
+    nested card exhausts the interpreter stack here, before the canonicalizer
+    ever gets the chance to reject it. `depth` counts open containers on the
+    path to `d`, the outermost at 1, and matches `_jcs.MAX_DEPTH`'s rule.
+    """
+    if isinstance(d, (dict, list)) and depth > MAX_DEPTH:
+        raise CanonicalizationError(
+            f'nesting exceeds the maximum depth of {MAX_DEPTH}'
+        )
+    if isinstance(d, dict):
+        cleaned_dict = {
+            k: cleaned_v
+            for k, v in d.items()
+            if (cleaned_v := _clean_empty(v, depth + 1)) is not None
+        }
+        return cleaned_dict or None
+    if isinstance(d, list):
+        cleaned_list = [
+            cleaned_v
+            for v in d
+            if (cleaned_v := _clean_empty(v, depth + 1)) is not None
+        ]
+        return cleaned_list or None
+    if isinstance(d, str) and not d:
+        return None
+    return d
+
+
+def _canonicalize_agent_card(agent_card: AgentCard) -> str:
+    """Canonicalizes the Agent Card JSON according to RFC 8785 (JCS)."""
+    warn_on_missing_required_fields(
+        agent_card, 'agent_card passed to _canonicalize_agent_card:'
+    )
+    card_dict = MessageToDict(
+        agent_card,
+    )
+    # Remove signatures field if present
+    card_dict.pop('signatures', None)
+
+    # Recursively remove empty values
+    cleaned_dict = _clean_empty(card_dict)
+    return canonicalize(cleaned_dict)
diff --git a/src/a2a/utils/task.py b/src/a2a/utils/task.py
index cd0da7e4f..0e340d7c5 100644
--- a/src/a2a/utils/task.py
+++ b/src/a2a/utils/task.py
@@ -1,14 +1,187 @@
-import uuid
+"""Utility functions for creating A2A Task objects."""
 
-from a2a.types import Message, Task, TaskState, TaskStatus
+import binascii
+import json
 
+from base64 import b64decode, b64encode, urlsafe_b64decode, urlsafe_b64encode
+from dataclasses import dataclass
+from typing import Literal, Protocol, runtime_checkable
 
-def new_task(request: Message) -> Task:
-    return Task(
-        status=TaskStatus(state=TaskState.submitted),
-        id=(request.taskId if request.taskId else str(uuid.uuid4())),
-        contextId=(
-            request.contextId if request.contextId else str(uuid.uuid4())
-        ),
-        history=[request],
+from a2a.types.a2a_pb2 import Task
+from a2a.utils.constants import MAX_LIST_TASKS_PAGE_SIZE
+from a2a.utils.errors import InvalidParamsError
+
+
+@runtime_checkable
+class HistoryLengthConfig(Protocol):
+    """Protocol for configuration arguments containing history_length field."""
+
+    history_length: int
+
+    def HasField(self, field_name: Literal['history_length']) -> bool:  # noqa: N802 -- Protobuf generated code
+        """Checks if a field is set.
+
+        This method name matches the generated Protobuf code.
+        """
+        ...
+
+
+def validate_history_length(config: HistoryLengthConfig | None) -> None:
+    """Validates that history_length is non-negative."""
+    if config and config.history_length < 0:
+        raise InvalidParamsError(message='history length must be non-negative')
+
+
+def apply_history_length(
+    task: Task, config: HistoryLengthConfig | None
+) -> Task:
+    """Applies history_length parameter on task and returns a new task object.
+
+    Args:
+        task: The original task object with complete history
+        config: Configuration object containing 'history_length' field and HasField method.
+
+    Returns:
+        A new task object with limited history
+
+    See Also:
+        https://a2a-protocol.org/latest/specification/#324-history-length-semantics
+    """
+    if config is None or not config.HasField('history_length'):
+        return task
+
+    history_length = config.history_length
+
+    if history_length == 0:
+        if not task.history:
+            return task
+        task_copy = Task()
+        task_copy.CopyFrom(task)
+        task_copy.ClearField('history')
+        return task_copy
+
+    if history_length > 0 and task.history:
+        if len(task.history) <= history_length:
+            return task
+
+        task_copy = Task()
+        task_copy.CopyFrom(task)
+        del task_copy.history[:-history_length]
+        return task_copy
+
+    return task
+
+
+def validate_page_size(page_size: int) -> None:
+    """Validates that page_size is in range [1, 100].
+
+    See Also:
+        https://a2a-protocol.org/latest/specification/#314-list-tasks
+    """
+    if page_size < 1:
+        raise InvalidParamsError(message='minimum page size is 1')
+    if page_size > MAX_LIST_TASKS_PAGE_SIZE:
+        raise InvalidParamsError(
+            message=f'maximum page size is {MAX_LIST_TASKS_PAGE_SIZE}'
+        )
+
+
+_ENCODING = 'utf-8'
+
+
+def encode_page_token(task_id: str) -> str:
+    """Encodes page token for tasks pagination.
+
+    Args:
+        task_id: The ID of the task.
+
+    Returns:
+        The encoded page token.
+    """
+    return b64encode(task_id.encode(_ENCODING)).decode(_ENCODING)
+
+
+def decode_page_token(page_token: str) -> str:
+    """Decodes page token for tasks pagination.
+
+    Args:
+        page_token: The encoded page token.
+
+    Returns:
+        The decoded task ID.
+    """
+    encoded_str = page_token
+    missing_padding = len(encoded_str) % 4
+    if missing_padding:
+        encoded_str += '=' * (4 - missing_padding)
+    try:
+        decoded = b64decode(encoded_str.encode(_ENCODING)).decode(_ENCODING)
+    except (binascii.Error, UnicodeDecodeError) as e:
+        raise InvalidParamsError(
+            'Token is not a valid base64-encoded cursor.'
+        ) from e
+    return decoded
+
+
+@dataclass(frozen=True)
+class ListTasksCursor:
+    """A position in the `ListTasks` sort order.
+
+    Tasks are listed by `(has timestamp, timestamp, id)` in descending order,
+    so tasks without a timestamp come last. A cursor names the last task of a
+    page; the next page starts strictly after it. Because the position is
+    carried in the token rather than looked up again, a page token stays valid
+    when that task is later updated or deleted.
+    """
+
+    timestamp_ns: int | None
+    task_id: str
+
+    def sort_key(self) -> tuple[bool, int, str]:
+        """The cursor's position as a `(has timestamp, timestamp, id)` key."""
+        return (
+            self.timestamp_ns is not None,
+            self.timestamp_ns or 0,
+            self.task_id,
+        )
+
+
+def encode_list_tasks_cursor(cursor: ListTasksCursor) -> str:
+    """Encodes a `ListTasksCursor` as an opaque, URL-safe page token."""
+    payload = json.dumps(
+        {'ts': cursor.timestamp_ns, 'id': cursor.task_id},
+        separators=(',', ':'),
+    )
+    return (
+        urlsafe_b64encode(payload.encode(_ENCODING))
+        .decode(_ENCODING)
+        .rstrip('=')
+    )
+
+
+def decode_list_tasks_cursor(page_token: str) -> ListTasksCursor | None:
+    """Decodes a page token produced by `encode_list_tasks_cursor`.
+
+    Args:
+        page_token: The page token from a previous `ListTasks` response.
+
+    Returns:
+        The decoded cursor, or None if the token is not a valid cursor token.
+        Callers treat None as a legacy task-ID token (see
+        `decode_page_token`), which also rejects tampered or unknown tokens.
+    """
+    padded = page_token + '=' * (-len(page_token) % 4)
+    try:
+        data = json.loads(urlsafe_b64decode(padded.encode(_ENCODING)))
+    except (binascii.Error, ValueError):
+        return None
+    if not isinstance(data, dict) or data.keys() != {'ts', 'id'}:
+        return None
+    timestamp_ns = data['ts']
+    task_id = data['id']
+    timestamp_is_valid = timestamp_ns is None or (
+        isinstance(timestamp_ns, int) and not isinstance(timestamp_ns, bool)
     )
+    if not timestamp_is_valid or not isinstance(task_id, str) or not task_id:
+        return None
+    return ListTasksCursor(timestamp_ns=timestamp_ns, task_id=task_id)
diff --git a/src/a2a/utils/telemetry.py b/src/a2a/utils/telemetry.py
index 926e37719..d20caadde 100644
--- a/src/a2a/utils/telemetry.py
+++ b/src/a2a/utils/telemetry.py
@@ -1,4 +1,3 @@
-# type: ignore
 """OpenTelemetry Tracing Utilities for A2A Python SDK.
 
 This module provides decorators to simplify the integration of OpenTelemetry
@@ -19,6 +18,16 @@
 - Automatic recording of exceptions and setting of span status.
 - Selective method tracing in classes using include/exclude lists.
 
+Configuration:
+- Environment Variable Control: OpenTelemetry instrumentation can be
+  disabled using the `OTEL_INSTRUMENTATION_A2A_SDK_ENABLED` environment
+  variable.
+
+  - Default: `true` (tracing enabled when OpenTelemetry is installed)
+  - To disable: Set `OTEL_INSTRUMENTATION_A2A_SDK_ENABLED=false`
+  - Case insensitive: 'true', 'True', 'TRUE' all enable tracing
+  - Any other value disables tracing and logs a debug message
+
 Usage:
     For a single function:
     ```python
@@ -54,28 +63,103 @@ def internal_method(self):
     ```
 """
 
+import asyncio
 import functools
 import inspect
 import logging
+import os
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from typing_extensions import Self
+
+from a2a.utils._async_queue_compat import QueueShutDown
 
-from opentelemetry import trace
-from opentelemetry.trace import SpanKind, StatusCode
 
+if TYPE_CHECKING:
+    from opentelemetry.trace import (
+        SpanKind as SpanKindType,
+    )
+else:
+    SpanKindType = object
+
+logger = logging.getLogger(__name__)
 
+try:
+    from opentelemetry import trace
+    from opentelemetry.trace import (
+        SpanKind as _SpanKind,
+    )
+    from opentelemetry.trace import (
+        StatusCode,
+    )
+
+    otel_installed = True
+
+except ImportError:
+    logger.debug(
+        'OpenTelemetry not found. Tracing will be disabled. '
+        'Install with: \'pip install "a2a-sdk[telemetry]"\''
+    )
+    otel_installed = False
+
+ENABLED_ENV_VAR = 'OTEL_INSTRUMENTATION_A2A_SDK_ENABLED'
 INSTRUMENTING_MODULE_NAME = 'a2a-python-sdk'
 INSTRUMENTING_MODULE_VERSION = '1.0.0'
 
-logger = logging.getLogger(__name__)
+# Check if tracing is enabled via environment variable
+env_value = os.getenv(ENABLED_ENV_VAR, 'true')
+otel_enabled = env_value.lower() == 'true'
+
+# Log when tracing is explicitly disabled via environment variable
+if otel_installed and not otel_enabled:
+    logger.debug(
+        'A2A OTEL instrumentation disabled via environment variable '
+        '%s=%r. Tracing will be disabled.',
+        ENABLED_ENV_VAR,
+        env_value,
+    )
 
+if not otel_installed or not otel_enabled:
 
-def trace_function(
-    func=None,
+    class _NoOp:
+        """A no-op object that absorbs all tracing calls when OpenTelemetry is not installed."""
+
+        def __call__(self, *args: Any, **kwargs: Any) -> Any:
+            return self
+
+        def __enter__(self) -> Self:
+            return self
+
+        def __exit__(self, *args: object, **kwargs: Any) -> None:
+            pass
+
+        def __getattr__(self, name: str) -> Any:
+            return self
+
+    trace = _NoOp()  # type: ignore
+    _SpanKind = _NoOp()  # type: ignore
+    StatusCode = _NoOp()  # type: ignore
+
+SpanKind = _SpanKind
+__all__ = ['SpanKind']
+
+
+_NON_ERROR_EXCEPTIONS: tuple[type[BaseException], ...] = (
+    asyncio.CancelledError,
+    QueueShutDown,
+)
+
+
+def trace_function(  # noqa: PLR0915
+    func: Callable | None = None,
     *,
-    span_name=None,
-    kind=SpanKind.INTERNAL,
-    attributes=None,
-    attribute_extractor=None,
-):
+    span_name: str | None = None,
+    kind: SpanKindType = SpanKind.INTERNAL,
+    attributes: dict[str, Any] | None = None,
+    attribute_extractor: Callable | None = None,
+) -> Callable:
     """A decorator to automatically trace a function call with OpenTelemetry.
 
     This decorator can be used to wrap both sync and async functions.
@@ -84,9 +168,9 @@ def trace_function(
     exceptions that occur.
 
     It can be used in two ways:
+
     1. As a direct decorator: `@trace_function`
-    2. As a decorator factory to provide arguments:
-    `@trace_function(span_name="custom.name")`
+    2. As a decorator factory to provide arguments: `@trace_function(span_name="custom.name")`
 
     Args:
         func (callable, optional): The function to be decorated. If None,
@@ -128,22 +212,32 @@ def trace_function(
             attribute_extractor=attribute_extractor,
         )
 
-    actual_span_name = span_name or f'{func.__module__}.{func.__name__}'
+    actual_span_name = span_name or f'{func.__module__}.{func.__name__}'  # ty:ignore[unresolved-attribute]
 
     is_async_func = inspect.iscoroutinefunction(func)
 
     logger.debug(
-        f'Start tracing for {actual_span_name}, is_async_func {is_async_func}'
+        'Start tracing for %s, is_async_func %s',
+        actual_span_name,
+        is_async_func,
     )
 
     @functools.wraps(func)
-    async def async_wrapper(*args, **kwargs) -> any:
+    async def async_wrapper(*args, **kwargs) -> Any:
         """Async Wrapper for the decorator."""
         logger.debug('Start async tracer')
         tracer = trace.get_tracer(
             INSTRUMENTING_MODULE_NAME, INSTRUMENTING_MODULE_VERSION
         )
-        with tracer.start_as_current_span(actual_span_name, kind=kind) as span:
+        # The wrapper records exceptions and sets the span status itself, so
+        # OTel must not do it again: it would mark non-error exceptions
+        # (e.g. `QueueShutDown`) as ERROR and record every exception twice.
+        with tracer.start_as_current_span(
+            actual_span_name,
+            kind=kind,
+            record_exception=False,
+            set_status_on_exception=False,
+        ) as span:
             if attributes:
                 for k, v in attributes.items():
                     span.set_attribute(k, v)
@@ -155,8 +249,15 @@ async def async_wrapper(*args, **kwargs) -> any:
                 # Async wrapper, await for the function call to complete.
                 result = await func(*args, **kwargs)
                 span.set_status(StatusCode.OK)
-                return result
-
+            except _NON_ERROR_EXCEPTIONS as ge:
+                exception = None
+                logger.debug(
+                    '%s in span %s',
+                    type(ge).__name__,
+                    actual_span_name,
+                )
+                span.record_exception(ge)
+                raise
             except Exception as e:
                 exception = e
                 span.record_exception(e)
@@ -168,16 +269,25 @@ async def async_wrapper(*args, **kwargs) -> any:
                         attribute_extractor(
                             span, args, kwargs, result, exception
                         )
-                    except Exception as attr_e:
-                        logger.error(
-                            f'attribute_extractor error in span {actual_span_name}: {attr_e}'
+                    except Exception:
+                        logger.exception(
+                            'attribute_extractor error in span %s',
+                            actual_span_name,
                         )
+            return result
 
     @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
+    def sync_wrapper(*args, **kwargs) -> Any:
         """Sync Wrapper for the decorator."""
         tracer = trace.get_tracer(INSTRUMENTING_MODULE_NAME)
-        with tracer.start_as_current_span(actual_span_name, kind=kind) as span:
+        # The wrapper records exceptions and sets the span status itself;
+        # letting OTel do it too would record every exception twice.
+        with tracer.start_as_current_span(
+            actual_span_name,
+            kind=kind,
+            record_exception=False,
+            set_status_on_exception=False,
+        ) as span:
             if attributes:
                 for k, v in attributes.items():
                     span.set_attribute(k, v)
@@ -189,7 +299,6 @@ def sync_wrapper(*args, **kwargs):
                 # Sync wrapper, execute the function call.
                 result = func(*args, **kwargs)
                 span.set_status(StatusCode.OK)
-                return result
 
             except Exception as e:
                 exception = e
@@ -202,31 +311,39 @@ def sync_wrapper(*args, **kwargs):
                         attribute_extractor(
                             span, args, kwargs, result, exception
                         )
-                    except Exception as attr_e:
-                        logger.error(
-                            f'attribute_extractor error in span {actual_span_name}: {attr_e}'
+                    except Exception:
+                        logger.exception(
+                            'attribute_extractor error in span %s',
+                            actual_span_name,
                         )
+            return result
 
     return async_wrapper if is_async_func else sync_wrapper
 
 
-def trace_class(include_list: list[str] = None, exclude_list: list[str] = None):
+def trace_class(
+    include_list: list[str] | None = None,
+    exclude_list: list[str] | None = None,
+    kind: SpanKindType = SpanKind.INTERNAL,
+) -> Callable:
     """A class decorator to automatically trace specified methods of a class.
 
     This decorator iterates over the methods of a class and applies the
     `trace_function` decorator to them, based on the `include_list` and
-    `exclude_list` criteria. Dunder methods (e.g., `__init__`, `__call__`)
-    are always excluded.
+    `exclude_list` criteria. Methods starting or ending with double underscores
+    (dunder methods, e.g., `__init__`, `__call__`) are always excluded by default.
 
     Args:
         include_list (list[str], optional): A list of method names to
             explicitly include for tracing. If provided, only methods in this
             list (that are not dunder methods) will be traced.
-            Defaults to None.
+            Defaults to None (trace all non-dunder methods).
         exclude_list (list[str], optional): A list of method names to exclude
             from tracing. This is only considered if `include_list` is not
             provided. Dunder methods are implicitly excluded.
             Defaults to an empty list.
+        kind (SpanKind, optional): The `opentelemetry.trace.SpanKind` for the
+            created spans on the methods. Defaults to `SpanKind.INTERNAL`.
 
     Returns:
         callable: A decorator function that, when applied to a class,
@@ -258,27 +375,24 @@ def not_traced_method(self):
                 pass
         ```
     """
-    logger.debug(f'Trace all class {include_list}, {exclude_list}')
+    logger.debug('Trace all class %s, %s', include_list, exclude_list)
     exclude_list = exclude_list or []
 
-    def decorator(cls):
-        all_methods = {}
+    def decorator(cls: Any) -> Any:
         for name, method in inspect.getmembers(cls, inspect.isfunction):
-            # Skip Dunders
             if name.startswith('__') and name.endswith('__'):
                 continue
-
-            # Skip if include list is defined but the method not included.
             if include_list and name not in include_list:
                 continue
-            # Skip if include list is not defined but the method is in excludes.
             if not include_list and name in exclude_list:
                 continue
 
-            all_methods[name] = method
             span_name = f'{cls.__module__}.{cls.__name__}.{name}'
-            # Set the decorator on the method.
-            setattr(cls, name, trace_function(span_name=span_name)(method))
+            setattr(
+                cls,
+                name,
+                trace_function(span_name=span_name, kind=kind)(method),
+            )
         return cls
 
     return decorator
diff --git a/src/a2a/utils/version_validator.py b/src/a2a/utils/version_validator.py
new file mode 100644
index 000000000..4a776c27e
--- /dev/null
+++ b/src/a2a/utils/version_validator.py
@@ -0,0 +1,130 @@
+"""General utility functions for the A2A Python SDK."""
+
+import functools
+import inspect
+import logging
+
+from collections.abc import AsyncIterator, Callable
+from typing import Any, TypeVar, cast
+
+from packaging.version import InvalidVersion, Version
+
+from a2a.server.context import ServerCallContext
+from a2a.utils import constants
+from a2a.utils.errors import VersionNotSupportedError
+
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+logger = logging.getLogger(__name__)
+
+
+def validate_version(expected_version: str) -> Callable[[F], F]:
+    """Decorator that validates the A2A-Version header in the request context.
+
+    The header name is defined by `constants.VERSION_HEADER` ('A2A-Version').
+    If the header is missing or empty, it is interpreted as `constants.PROTOCOL_VERSION_0_3` ('0.3').
+    If the version in the header does not match the `expected_version` (major and minor parts),
+    a `VersionNotSupportedError` is raised. Patch version is ignored.
+
+    This decorator supports both async methods and async generator methods. It
+    expects a `ServerCallContext` to be present either in the arguments or
+    keyword arguments of the decorated method.
+
+    Args:
+        expected_version: The A2A protocol version string expected by the method.
+
+    Returns:
+        The decorated function.
+
+    Raises:
+        VersionNotSupportedError: If the version in the request does not match `expected_version`.
+    """
+    try:
+        expected_v = Version(expected_version)
+    except InvalidVersion:
+        # If the expected version is not a valid semver, we can't do major/minor comparison.
+        # This shouldn't happen with our constants.
+        expected_v = None
+
+    def decorator(func: F) -> F:
+        def _get_actual_version(
+            args: tuple[Any, ...], kwargs: dict[str, Any]
+        ) -> str:
+            context = kwargs.get('context')
+            if context is None:
+                for arg in args:
+                    if isinstance(arg, ServerCallContext):
+                        context = arg
+                        break
+
+            if context is None:
+                # If no context is found, we can't validate the version.
+                # In a real scenario, this shouldn't happen for properly routed requests.
+                # We default to the expected version to allow test call to proceed.
+                return expected_version
+
+            headers = context.state.get('headers', {})
+            # Header names are usually case-insensitive in most frameworks, but dict lookup is case-sensitive.
+            # We check both standard and lowercase versions.
+            actual_version = headers.get(
+                constants.VERSION_HEADER
+            ) or headers.get(constants.VERSION_HEADER.lower())
+
+            if not actual_version:
+                return constants.PROTOCOL_VERSION_0_3
+
+            return str(actual_version)
+
+        def _is_version_compatible(actual: str) -> bool:
+            if actual == expected_version:
+                return True
+            if not expected_v:
+                return False
+            try:
+                actual_v = Version(actual)
+            except InvalidVersion:
+                return False
+            else:
+                return actual_v.major == expected_v.major
+
+        if inspect.isasyncgenfunction(inspect.unwrap(func)):
+
+            @functools.wraps(func)
+            def async_gen_wrapper(
+                *args: Any, **kwargs: Any
+            ) -> AsyncIterator[Any]:
+                actual_version = _get_actual_version(args, kwargs)
+                if not _is_version_compatible(actual_version):
+                    logger.warning(
+                        "Version mismatch: actual='%s', expected='%s'",
+                        actual_version,
+                        expected_version,
+                    )
+                    raise VersionNotSupportedError(
+                        message=f"A2A version '{actual_version}' is not supported by this handler. "
+                        f"Expected version '{expected_version}'."
+                    )
+                return func(*args, **kwargs)
+
+            return cast('F', async_gen_wrapper)
+
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            actual_version = _get_actual_version(args, kwargs)
+            if not _is_version_compatible(actual_version):
+                logger.warning(
+                    "Version mismatch: actual='%s', expected='%s'",
+                    actual_version,
+                    expected_version,
+                )
+                raise VersionNotSupportedError(
+                    message=f"A2A version '{actual_version}' is not supported by this handler. "
+                    f"Expected version '{expected_version}'."
+                )
+            return await func(*args, **kwargs)
+
+        return cast('F', async_wrapper)
+
+    return decorator
diff --git a/tck/__init__.py b/tck/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tck/sut_agent.py b/tck/sut_agent.py
new file mode 100644
index 000000000..206774c64
--- /dev/null
+++ b/tck/sut_agent.py
@@ -0,0 +1,263 @@
+import asyncio
+import logging
+import os
+import uuid
+
+from datetime import datetime, timezone
+
+import grpc.aio
+import uvicorn
+
+from starlette.applications import Starlette
+
+import a2a.compat.v0_3.a2a_v0_3_pb2_grpc as a2a_v0_3_grpc
+import a2a.types.a2a_pb2_grpc as a2a_grpc
+
+from a2a.compat.v0_3.grpc_handler import CompatGrpcHandler
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.request_handlers.grpc_handler import GrpcHandler
+from a2a.server.routes import (
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+    Message,
+    Part,
+    Role,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+
+JSONRPC_URL = '/a2a/jsonrpc'
+REST_URL = '/a2a/rest'
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger('SUTAgent')
+
+
+class SUTAgentExecutor(AgentExecutor):
+    """Execution logic for the SUT agent."""
+
+    def __init__(self) -> None:
+        """Initializes the SUT agent executor."""
+        self.running_tasks: set[str] = set()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Cancels a task."""
+        api_task_id = context.task_id
+        if api_task_id is None:
+            return
+        if api_task_id in self.running_tasks:
+            self.running_tasks.remove(api_task_id)
+
+        status_update = TaskStatusUpdateEvent(
+            task_id=api_task_id,
+            context_id=context.context_id or str(uuid.uuid4()),
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_CANCELED,
+                timestamp=datetime.now(timezone.utc),
+            ),
+        )
+        await event_queue.enqueue_event(status_update)
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        """Executes a task."""
+        user_message = context.message
+        task_id = context.task_id
+        if user_message is None or task_id is None:
+            return
+        context_id = context.context_id
+
+        self.running_tasks.add(task_id)
+
+        # 1.0 semantics: the Task itself must be enqueued before any
+        # TaskStatusUpdateEvent (the SDK enforces this ordering).
+        task = context.current_task
+        if not task:
+            task = new_task_from_user_message(user_message)
+            await event_queue.enqueue_event(task)
+
+        logger.info(
+            '[SUTAgentExecutor] Processing message %s for task %s (context: %s)',
+            user_message.message_id,
+            task_id,
+            context_id,
+        )
+
+        working_status = TaskStatusUpdateEvent(
+            task_id=task_id,
+            context_id=context_id,
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_WORKING,
+                message=Message(
+                    role=Role.ROLE_AGENT,
+                    message_id=str(uuid.uuid4()),
+                    parts=[Part(text='Processing your question')],
+                    task_id=task_id,
+                    context_id=context_id,
+                ),
+                timestamp=datetime.now(timezone.utc),
+            ),
+        )
+        await event_queue.enqueue_event(working_status)
+
+        agent_reply_text = 'Hello world!'
+        await asyncio.sleep(3)  # Simulate processing delay
+
+        if task_id not in self.running_tasks:
+            logger.info('Task %s was cancelled.', task_id)
+            return
+
+        logger.info('[SUTAgentExecutor] Response: %s', agent_reply_text)
+
+        agent_message = Message(
+            role=Role.ROLE_AGENT,
+            message_id=str(uuid.uuid4()),
+            parts=[Part(text=agent_reply_text)],
+            task_id=task_id,
+            context_id=context_id,
+        )
+
+        final_update = TaskStatusUpdateEvent(
+            task_id=task_id,
+            context_id=context_id,
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_INPUT_REQUIRED,
+                message=agent_message,
+                timestamp=datetime.now(timezone.utc),
+            ),
+        )
+        await event_queue.enqueue_event(final_update)
+
+
+def serve(task_store: TaskStore) -> None:
+    """Sets up the A2A service and starts the HTTP server."""
+    http_port = int(os.environ.get('HTTP_PORT', '41241'))
+
+    grpc_port = int(os.environ.get('GRPC_PORT', '50051'))
+
+    agent_card = AgentCard(
+        name='SUT Agent',
+        description='An agent to be used as SUT against TCK tests.',
+        supported_interfaces=[
+            AgentInterface(
+                url=f'http://localhost:{http_port}{JSONRPC_URL}',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0.0',
+            ),
+            AgentInterface(
+                url=f'http://localhost:{http_port}{REST_URL}',
+                protocol_binding='HTTP+JSON',
+                protocol_version='1.0.0',
+            ),
+            AgentInterface(
+                url=f'localhost:{grpc_port}',
+                protocol_binding='GRPC',
+                protocol_version='1.0.0',
+            ),
+        ],
+        provider=AgentProvider(
+            organization='A2A Samples',
+            url='https://example.com/a2a-samples',
+        ),
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=False,
+        ),
+        default_input_modes=['text'],
+        default_output_modes=['text', 'task-status'],
+        skills=[
+            AgentSkill(
+                id='sut_agent',
+                name='SUT Agent',
+                description='Simulate the general flow of a streaming agent.',
+                tags=['sut'],
+                examples=['hi', 'hello world', 'how are you', 'goodbye'],
+                input_modes=['text'],
+                output_modes=['text', 'task-status'],
+            )
+        ],
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_card=agent_card,
+        agent_executor=SUTAgentExecutor(),
+        task_store=task_store,
+    )
+
+    # JSONRPC
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=request_handler,
+        rpc_url=JSONRPC_URL,
+    )
+    # Agent Card
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card,
+    )
+    # REST
+    rest_routes = create_rest_routes(
+        request_handler=request_handler,
+        path_prefix=REST_URL,
+    )
+
+    routes = [
+        *jsonrpc_routes,
+        *agent_card_routes,
+        *rest_routes,
+    ]
+    main_app = Starlette(routes=routes)
+
+    config = uvicorn.Config(
+        main_app, host='127.0.0.1', port=http_port, log_level='info'
+    )
+    uvicorn_server = uvicorn.Server(config)
+
+    # GRPC
+    grpc_server = grpc.aio.server()
+    grpc_server.add_insecure_port(f'[::]:{grpc_port}')
+    servicer = GrpcHandler(request_handler)
+    compat_servicer = CompatGrpcHandler(request_handler)
+    a2a_grpc.add_A2AServiceServicer_to_server(servicer, grpc_server)
+    a2a_v0_3_grpc.add_A2AServiceServicer_to_server(compat_servicer, grpc_server)
+
+    logger.info(
+        'Starting HTTP server on port %s and gRPC on port %s...',
+        http_port,
+        grpc_port,
+    )
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(grpc_server.start())
+    loop.run_until_complete(
+        asyncio.gather(
+            uvicorn_server.serve(), grpc_server.wait_for_termination()
+        )
+    )
+
+
+def main() -> None:
+    """Main entrypoint."""
+    serve(InMemoryTaskStore())
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tck/sut_agent_with_vertex_task_store.py b/tck/sut_agent_with_vertex_task_store.py
new file mode 100644
index 000000000..0fadcdd94
--- /dev/null
+++ b/tck/sut_agent_with_vertex_task_store.py
@@ -0,0 +1,54 @@
+import os
+
+import sut_agent
+
+
+try:
+    import vertexai
+except ImportError as e:
+    raise ImportError(
+        'VertexTaskStore requires vertexai. '
+        'Install with: '
+        "'pip install a2a-sdk[vertex]'"
+    ) from e
+
+from a2a.contrib.tasks.vertex_task_store import VertexTaskStore
+
+
+def main() -> None:
+    """Main entrypoint."""
+    project = os.environ.get('VERTEX_PROJECT')
+    location = os.environ.get('VERTEX_LOCATION')
+    base_url = os.environ.get('VERTEX_BASE_URL')
+    api_version = os.environ.get('VERTEX_API_VERSION')
+    agent_engine_resource_id = os.environ.get('AGENT_ENGINE_RESOURCE_ID')
+
+    if (
+        not project
+        or not location
+        or not base_url
+        or not api_version
+        or not agent_engine_resource_id
+    ):
+        raise ValueError(
+            'Environment variables VERTEX_PROJECT, VERTEX_LOCATION, '
+            'VERTEX_BASE_URL, VERTEX_API_VERSION, and '
+            'AGENT_ENGINE_RESOURCE_ID must be defined'
+        )
+
+    client = vertexai.Client(
+        project=project,
+        location=location,
+        http_options={'base_url': base_url, 'api_version': api_version},
+    )
+
+    sut_agent.serve(
+        VertexTaskStore(
+            client=client,
+            agent_engine_resource_id=agent_engine_resource_id,
+        )
+    )
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 000000000..f16379b19
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,59 @@
+## Running the tests
+
+1. Run all tests (excluding those requiring real DBs, see item 3):
+    ```bash
+    uv run pytest
+    ```
+
+    ```
+
+    **Useful Flags:**
+    - `-v` (verbose): Shows more detailed output, including each test name as it runs.
+    - `-s` (no capture): Allows stdout (print statements) to show in the console. Useful for debugging.
+
+    Example with flags:
+    ```bash
+    uv run pytest -v -s
+    ```
+
+    Note: Some tests require external databases (PostgreSQL, MySQL) and will be skipped if the corresponding environment variables (`POSTGRES_TEST_DSN`, `MYSQL_TEST_DSN`) are not set.
+
+2. Run specific tests:
+    ```bash
+    # Run a specific test file
+    uv run pytest tests/client/test_client_factory.py
+
+    # Run a specific test function
+    uv run pytest tests/client/test_client_factory.py::test_client_factory_connect_with_url
+
+    # Run tests in a specific folder
+    uv run pytest tests/client/
+    ```
+
+3. Run database integration tests (requires Docker):
+    ```bash
+    ./scripts/run_db_tests.sh
+    ```
+
+    This script will:
+    - Start PostgreSQL and MySQL containers using Docker Compose.
+    - Run the database integration tests.
+    - Stop the containers after tests finish.
+
+    You can also run tests for a specific database:
+    ```bash
+    ./scripts/run_db_tests.sh --postgres
+    # or
+    ./scripts/run_db_tests.sh --mysql
+    ```
+
+    To keep the databases running for debugging:
+    ```bash
+    ./scripts/run_db_tests.sh --debug
+    ```
+    (Follow the onscreen instructions to export DSNs and run pytest manually).
+
+In case of failures, you can clean  up the cache:
+
+1. `uv clean`
+2. `rm -fR .pytest_cache .venv __pycache__`
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/auth/test_user.py b/tests/auth/test_user.py
new file mode 100644
index 000000000..e3bbe2e60
--- /dev/null
+++ b/tests/auth/test_user.py
@@ -0,0 +1,27 @@
+import unittest
+
+from inspect import isabstract
+
+from a2a.auth.user import UnauthenticatedUser, User
+
+
+class TestUser(unittest.TestCase):
+    def test_is_abstract(self):
+        self.assertTrue(isabstract(User))
+
+
+class TestUnauthenticatedUser(unittest.TestCase):
+    def test_is_user_subclass(self):
+        self.assertTrue(issubclass(UnauthenticatedUser, User))
+
+    def test_is_authenticated_returns_false(self):
+        user = UnauthenticatedUser()
+        self.assertFalse(user.is_authenticated)
+
+    def test_user_name_returns_empty_string(self):
+        user = UnauthenticatedUser()
+        self.assertEqual(user.user_name, '')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/client/test_auth_interceptor.py b/tests/client/test_auth_interceptor.py
new file mode 100644
index 000000000..f7979bff7
--- /dev/null
+++ b/tests/client/test_auth_interceptor.py
@@ -0,0 +1,334 @@
+# ruff: noqa: INP001, S106
+import json
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+import pytest
+import respx
+
+from a2a.client import (
+    AuthInterceptor,
+    Client,
+    ClientCallContext,
+    ClientConfig,
+    ClientFactory,
+    InMemoryContextCredentialStore,
+)
+from a2a.client.interceptors import BeforeArgs
+from a2a.types.a2a_pb2 import (
+    APIKeySecurityScheme,
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AuthorizationCodeOAuthFlow,
+    HTTPAuthSecurityScheme,
+    Message,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    OpenIdConnectSecurityScheme,
+    Role,
+    SecurityRequirement,
+    SecurityScheme,
+    SendMessageRequest,
+    SendMessageResponse,
+    StringList,
+)
+from a2a.utils.constants import TransportProtocol
+from google.protobuf import json_format
+
+
+def build_success_response(request: httpx.Request) -> httpx.Response:
+    """Creates a valid JSON-RPC success response based on the request."""
+
+    request_payload = json.loads(request.content)
+    message = Message(
+        message_id='message-id',
+        role=Role.ROLE_AGENT,
+        parts=[],
+    )
+    response = SendMessageResponse(message=message)
+    response_payload = {
+        'id': request_payload['id'],
+        'jsonrpc': '2.0',
+        'result': json_format.MessageToDict(response),
+    }
+    return httpx.Response(200, json=response_payload)
+
+
+def build_message() -> Message:
+    """Builds a minimal Message."""
+    return Message(
+        message_id='msg1',
+        role=Role.ROLE_USER,
+        parts=[],
+    )
+
+
+async def send_message(
+    client: Client,
+    url: str,
+    session_id: str | None = None,
+) -> httpx.Request:
+    """Mocks the response and sends a message using the client."""
+    respx.post(url).mock(side_effect=build_success_response)
+    context = ClientCallContext(
+        state={'sessionId': session_id} if session_id else {}
+    )
+    request = SendMessageRequest(message=build_message())
+    async for _ in client.send_message(
+        request=request,
+        context=context,
+    ):
+        pass
+    return respx.calls.last.request
+
+
+@pytest.fixture
+def store():
+    store = InMemoryContextCredentialStore()
+    yield store
+
+
+@pytest.mark.asyncio
+async def test_auth_interceptor_skips_when_no_agent_card(
+    store: InMemoryContextCredentialStore,
+) -> None:
+    """Tests that the AuthInterceptor does not modify the request when no AgentCard is provided."""
+    auth_interceptor = AuthInterceptor(credential_service=store)
+    request = SendMessageRequest(message=Message())
+    context = ClientCallContext(state={})
+    args = BeforeArgs(
+        input=request,
+        method='send_message',
+        agent_card=AgentCard(),
+        context=context,
+    )
+
+    await auth_interceptor.before(args)
+    assert context.service_parameters is None
+
+
+@pytest.mark.asyncio
+async def test_in_memory_context_credential_store(
+    store: InMemoryContextCredentialStore,
+) -> None:
+    """Verifies that InMemoryContextCredentialStore correctly stores and retrieves
+    credentials based on the session ID in the client context.
+    """
+    session_id = 'session-id'
+    scheme_name = 'test-scheme'
+    credential = 'test-token'
+    await store.set_credentials(session_id, scheme_name, credential)
+
+    # Assert: Successful retrieval
+    context = ClientCallContext(state={'sessionId': session_id})
+    retrieved_credential = await store.get_credentials(scheme_name, context)
+    assert retrieved_credential == credential
+    # Assert: Retrieval with wrong session ID returns None
+    wrong_context = ClientCallContext(state={'sessionId': 'wrong-session'})
+    retrieved_credential_wrong = await store.get_credentials(
+        scheme_name, wrong_context
+    )
+    assert retrieved_credential_wrong is None
+    # Assert: Retrieval with no context returns None
+    retrieved_credential_none = await store.get_credentials(scheme_name, None)
+    assert retrieved_credential_none is None
+    # Assert: Retrieval with context but no sessionId returns None
+    empty_context = ClientCallContext(state={})
+    retrieved_credential_empty = await store.get_credentials(
+        scheme_name, empty_context
+    )
+    assert retrieved_credential_empty is None
+    # Assert: Overwrite the credential when session_id already exists
+    new_credential = 'new-token'
+    await store.set_credentials(session_id, scheme_name, new_credential)
+    assert await store.get_credentials(scheme_name, context) == new_credential
+
+
+def wrap_security_scheme(scheme: Any) -> SecurityScheme:
+    """Wraps a security scheme in the correct SecurityScheme proto field."""
+    if isinstance(scheme, APIKeySecurityScheme):
+        return SecurityScheme(api_key_security_scheme=scheme)
+    if isinstance(scheme, HTTPAuthSecurityScheme):
+        return SecurityScheme(http_auth_security_scheme=scheme)
+    if isinstance(scheme, OAuth2SecurityScheme):
+        return SecurityScheme(oauth2_security_scheme=scheme)
+    if isinstance(scheme, OpenIdConnectSecurityScheme):
+        return SecurityScheme(open_id_connect_security_scheme=scheme)
+    raise ValueError(f'Unknown security scheme type: {type(scheme)}')
+
+
+@dataclass
+class AuthTestCase:
+    """Represents a test scenario for verifying authentication behavior in AuthInterceptor."""
+
+    url: str
+    """The endpoint URL of the agent to which the request is sent."""
+    session_id: str
+    """The client session ID used to fetch credentials from the credential store."""
+    scheme_name: str
+    """The name of the security scheme defined in the agent card."""
+    credential: str
+    """The actual credential value (e.g., API key, access token) to be injected."""
+    security_scheme: Any
+    """The security scheme object (e.g., APIKeySecurityScheme, OAuth2SecurityScheme, etc.) to define behavior."""
+    expected_header_key: str
+    """The expected HTTP header name to be set by the interceptor."""
+    expected_header_value_func: Callable[[str], str]
+    """A function that maps the credential to its expected header value (e.g., lambda c: f"Bearer {c}")."""
+
+
+api_key_test_case = AuthTestCase(
+    url='http://agent.com/rpc',
+    session_id='session-id',
+    scheme_name='apikey',
+    credential='secret-api-key',
+    security_scheme=APIKeySecurityScheme(
+        name='X-API-Key',
+        location='header',
+    ),
+    expected_header_key='x-api-key',
+    expected_header_value_func=lambda c: c,
+)
+
+
+oauth2_test_case = AuthTestCase(
+    url='http://agent.com/rpc',
+    session_id='session-id',
+    scheme_name='oauth2',
+    credential='secret-oauth-access-token',
+    security_scheme=OAuth2SecurityScheme(
+        flows=OAuthFlows(
+            authorization_code=AuthorizationCodeOAuthFlow(
+                authorization_url='http://provider.com/auth',
+                token_url='http://provider.com/token',
+            )
+        ),
+    ),
+    expected_header_key='Authorization',
+    expected_header_value_func=lambda c: f'Bearer {c}',
+)
+
+
+oidc_test_case = AuthTestCase(
+    url='http://agent.com/rpc',
+    session_id='session-id',
+    scheme_name='oidc',
+    credential='secret-oidc-id-token',
+    security_scheme=OpenIdConnectSecurityScheme(
+        open_id_connect_url='http://provider.com/.well-known/openid-configuration',
+    ),
+    expected_header_key='Authorization',
+    expected_header_value_func=lambda c: f'Bearer {c}',
+)
+
+
+bearer_test_case = AuthTestCase(
+    url='http://agent.com/rpc',
+    session_id='session-id',
+    scheme_name='bearer',
+    credential='bearer-token-123',
+    security_scheme=HTTPAuthSecurityScheme(
+        scheme='bearer',
+    ),
+    expected_header_key='Authorization',
+    expected_header_value_func=lambda c: f'Bearer {c}',
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'test_case',
+    [api_key_test_case, oauth2_test_case, oidc_test_case, bearer_test_case],
+)
+@respx.mock
+async def test_auth_interceptor_variants(
+    test_case: AuthTestCase, store: InMemoryContextCredentialStore
+) -> None:
+    """Parametrized test verifying that AuthInterceptor correctly attaches credentials based on the defined security scheme in the AgentCard."""
+    await store.set_credentials(
+        test_case.session_id, test_case.scheme_name, test_case.credential
+    )
+    auth_interceptor = AuthInterceptor(credential_service=store)
+    agent_card = AgentCard(
+        supported_interfaces=[
+            AgentInterface(
+                url=test_case.url, protocol_binding=TransportProtocol.JSONRPC
+            )
+        ],
+        name=f'{test_case.scheme_name}bot',
+        description=f'A bot that uses {test_case.scheme_name}',
+        version='1.0',
+        default_input_modes=[],
+        default_output_modes=[],
+        skills=[],
+        capabilities=AgentCapabilities(),
+        security_requirements=[
+            SecurityRequirement(schemes={test_case.scheme_name: StringList()})
+        ],
+        security_schemes={
+            test_case.scheme_name: wrap_security_scheme(
+                test_case.security_scheme
+            )
+        },
+    )
+
+    async with httpx.AsyncClient() as http_client:
+        config = ClientConfig(
+            httpx_client=http_client,
+            supported_protocol_bindings=[TransportProtocol.JSONRPC],
+        )
+        factory = ClientFactory(config)
+        client = factory.create(agent_card, interceptors=[auth_interceptor])
+
+        request = await send_message(
+            client, test_case.url, test_case.session_id
+        )
+        assert request.headers[
+            test_case.expected_header_key
+        ] == test_case.expected_header_value_func(test_case.credential)
+
+
+@pytest.mark.asyncio
+async def test_auth_interceptor_skips_when_scheme_not_in_security_schemes(
+    store: InMemoryContextCredentialStore,
+) -> None:
+    """Tests that AuthInterceptor skips a scheme if it's listed in security requirements but not defined in security_schemes."""
+    scheme_name = 'missing'
+    session_id = 'session-id'
+    credential = 'test-token'
+    await store.set_credentials(session_id, scheme_name, credential)
+    auth_interceptor = AuthInterceptor(credential_service=store)
+    agent_card = AgentCard(
+        supported_interfaces=[
+            AgentInterface(
+                url='http://agent.com/rpc',
+                protocol_binding=TransportProtocol.JSONRPC,
+            )
+        ],
+        name='missingbot',
+        description='A bot that uses missing scheme definition',
+        version='1.0',
+        default_input_modes=[],
+        default_output_modes=[],
+        skills=[],
+        capabilities=AgentCapabilities(),
+        security_requirements=[
+            SecurityRequirement(schemes={scheme_name: StringList()})
+        ],
+        security_schemes={},
+    )
+    request = SendMessageRequest(message=Message())
+    context = ClientCallContext(state={'sessionId': session_id})
+    args = BeforeArgs(
+        input=request,
+        method='send_message',
+        agent_card=agent_card,
+        context=context,
+    )
+
+    await auth_interceptor.before(args)
+    assert context.service_parameters is None
diff --git a/tests/client/test_base_client.py b/tests/client/test_base_client.py
new file mode 100644
index 000000000..43d2b0766
--- /dev/null
+++ b/tests/client/test_base_client.py
@@ -0,0 +1,276 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from a2a.client.base_client import BaseClient
+from a2a.client.client import ClientConfig
+from a2a.client.transports.base import ClientTransport
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+
+
+@pytest.fixture
+def mock_transport() -> AsyncMock:
+    return AsyncMock(spec=ClientTransport)
+
+
+@pytest.fixture
+def sample_agent_card() -> AgentCard:
+    return AgentCard(
+        name='Test Agent',
+        description='An agent for testing',
+        supported_interfaces=[
+            AgentInterface(url='http://test.com', protocol_binding='HTTP+JSON')
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[],
+    )
+
+
+@pytest.fixture
+def sample_message() -> Message:
+    return Message(
+        role=Role.ROLE_USER,
+        message_id='msg-1',
+        parts=[Part(text='Hello')],
+    )
+
+
+@pytest.fixture
+def base_client(
+    sample_agent_card: AgentCard, mock_transport: AsyncMock
+) -> BaseClient:
+    config = ClientConfig(streaming=True)
+    return BaseClient(
+        card=sample_agent_card,
+        config=config,
+        transport=mock_transport,
+        interceptors=[],
+    )
+
+
+class TestClientTransport:
+    @pytest.mark.asyncio
+    async def test_transport_async_context_manager(self) -> None:
+        with (
+            patch.object(ClientTransport, '__abstractmethods__', set()),
+            patch.object(ClientTransport, 'close', new_callable=AsyncMock),
+        ):
+            transport = ClientTransport()
+            async with transport as t:
+                assert t is transport
+                transport.close.assert_not_awaited()
+            transport.close.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_transport_async_context_manager_on_exception(self) -> None:
+        with (
+            patch.object(ClientTransport, '__abstractmethods__', set()),
+            patch.object(ClientTransport, 'close', new_callable=AsyncMock),
+        ):
+            transport = ClientTransport()
+            with pytest.raises(RuntimeError, match='boom'):
+                async with transport:
+                    raise RuntimeError('boom')
+            transport.close.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_base_client_async_context_manager(
+        self, base_client: BaseClient, mock_transport: AsyncMock
+    ) -> None:
+        async with base_client as client:
+            assert client is base_client
+            mock_transport.close.assert_not_awaited()
+        mock_transport.close.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_base_client_async_context_manager_on_exception(
+        self, base_client: BaseClient, mock_transport: AsyncMock
+    ) -> None:
+        with pytest.raises(RuntimeError, match='boom'):
+            async with base_client:
+                raise RuntimeError('boom')
+        mock_transport.close.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_send_message_streaming(
+        self,
+        base_client: BaseClient,
+        mock_transport: MagicMock,
+        sample_message: Message,
+    ) -> None:
+        async def create_stream(*args, **kwargs):
+            task = Task(
+                id='task-123',
+                context_id='ctx-456',
+                status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+            )
+            stream_response = StreamResponse()
+            stream_response.task.CopyFrom(task)
+            yield stream_response
+
+        mock_transport.send_message_streaming.return_value = create_stream()
+
+        meta = {'test': 1}
+        request = SendMessageRequest(message=sample_message, metadata=meta)
+        stream = base_client.send_message(request)
+        events = [event async for event in stream]
+
+        mock_transport.send_message_streaming.assert_called_once()
+        assert (
+            mock_transport.send_message_streaming.call_args[0][0].metadata
+            == meta
+        )
+        assert not mock_transport.send_message.called
+        assert len(events) == 1
+        response = events[0]
+        assert response.task.id == 'task-123'
+
+    @pytest.mark.asyncio
+    async def test_send_message_non_streaming(
+        self,
+        base_client: BaseClient,
+        mock_transport: MagicMock,
+        sample_message: Message,
+    ) -> None:
+        base_client._config.streaming = False
+        task = Task(
+            id='task-456',
+            context_id='ctx-789',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+        response = SendMessageResponse()
+        response.task.CopyFrom(task)
+        mock_transport.send_message.return_value = response
+
+        meta = {'test': 1}
+        request = SendMessageRequest(message=sample_message, metadata=meta)
+        stream = base_client.send_message(request)
+        events = [event async for event in stream]
+
+        mock_transport.send_message.assert_called_once()
+        assert mock_transport.send_message.call_args[0][0].metadata == meta
+        assert not mock_transport.send_message_streaming.called
+        assert len(events) == 1
+        response = events[0]
+        assert response.task.id == 'task-456'
+
+    @pytest.mark.asyncio
+    async def test_send_message_non_streaming_agent_capability_false(
+        self,
+        base_client: BaseClient,
+        mock_transport: MagicMock,
+        sample_message: Message,
+    ) -> None:
+        base_client._card.capabilities.streaming = False
+        task = Task(
+            id='task-789',
+            context_id='ctx-101',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+        response = SendMessageResponse()
+        response.task.CopyFrom(task)
+        mock_transport.send_message.return_value = response
+
+        request = SendMessageRequest(message=sample_message)
+        events = [event async for event in base_client.send_message(request)]
+
+        mock_transport.send_message.assert_called_once()
+        assert not mock_transport.send_message_streaming.called
+        assert len(events) == 1
+        response = events[0]
+        assert response.task.id == 'task-789'
+
+    @pytest.mark.asyncio
+    async def test_send_message_callsite_config_overrides_non_streaming(
+        self,
+        base_client: BaseClient,
+        mock_transport: MagicMock,
+        sample_message: Message,
+    ):
+        base_client._config.streaming = False
+        task = Task(
+            id='task-cfg-ns-1',
+            context_id='ctx-cfg-ns-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+        response = SendMessageResponse()
+        response.task.CopyFrom(task)
+        mock_transport.send_message.return_value = response
+
+        cfg = SendMessageConfiguration(
+            history_length=2,
+            return_immediately=True,
+            accepted_output_modes=['application/json'],
+        )
+        request = SendMessageRequest(message=sample_message, configuration=cfg)
+        events = [event async for event in base_client.send_message(request)]
+
+        mock_transport.send_message.assert_called_once()
+        assert not mock_transport.send_message_streaming.called
+        assert len(events) == 1
+        response = events[0]
+        assert response.task.id == 'task-cfg-ns-1'
+
+        params = mock_transport.send_message.call_args[0][0]
+        assert params.configuration.history_length == 2
+        assert params.configuration.return_immediately is True
+        assert params.configuration.accepted_output_modes == [
+            'application/json'
+        ]
+
+    @pytest.mark.asyncio
+    async def test_send_message_callsite_config_overrides_streaming(
+        self,
+        base_client: BaseClient,
+        mock_transport: MagicMock,
+        sample_message: Message,
+    ):
+        base_client._config.streaming = True
+        base_client._card.capabilities.streaming = True
+
+        async def create_stream(*args, **kwargs):
+            task = Task(
+                id='task-cfg-s-1',
+                context_id='ctx-cfg-s-1',
+                status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+            )
+            stream_response = StreamResponse()
+            stream_response.task.CopyFrom(task)
+            yield stream_response
+
+        mock_transport.send_message_streaming.return_value = create_stream()
+
+        cfg = SendMessageConfiguration(
+            history_length=0,
+            accepted_output_modes=['text/plain'],
+        )
+        request = SendMessageRequest(message=sample_message, configuration=cfg)
+        events = [event async for event in base_client.send_message(request)]
+
+        mock_transport.send_message_streaming.assert_called_once()
+        assert not mock_transport.send_message.called
+        assert len(events) == 1
+        response = events[0]
+        assert response.task.id == 'task-cfg-s-1'
+
+        params = mock_transport.send_message_streaming.call_args[0][0]
+        assert params.configuration.history_length == 0
+        assert params.configuration.return_immediately is False
+        assert params.configuration.accepted_output_modes == ['text/plain']
diff --git a/tests/client/test_base_client_interceptors.py b/tests/client/test_base_client_interceptors.py
new file mode 100644
index 000000000..d7930062f
--- /dev/null
+++ b/tests/client/test_base_client_interceptors.py
@@ -0,0 +1,240 @@
+# ruff: noqa: INP001
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from a2a.client.base_client import BaseClient
+from a2a.client.client import ClientConfig
+from a2a.client.interceptors import (
+    AfterArgs,
+    BeforeArgs,
+    ClientCallInterceptor,
+)
+from a2a.client.transports.base import ClientTransport
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Message,
+    StreamResponse,
+)
+
+
+@pytest.fixture
+def mock_transport() -> AsyncMock:
+    return AsyncMock(spec=ClientTransport)
+
+
+@pytest.fixture
+def sample_agent_card() -> AgentCard:
+    return AgentCard(
+        name='Test Agent',
+        description='An agent for testing',
+        supported_interfaces=[
+            AgentInterface(url='http://test.com', protocol_binding='HTTP+JSON')
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[],
+    )
+
+
+@pytest.fixture
+def mock_interceptor() -> AsyncMock:
+    return AsyncMock(spec=ClientCallInterceptor)
+
+
+@pytest.fixture
+def base_client(
+    sample_agent_card: AgentCard,
+    mock_transport: AsyncMock,
+    mock_interceptor: AsyncMock,
+) -> BaseClient:
+    config = ClientConfig(streaming=True)
+    return BaseClient(
+        card=sample_agent_card,
+        config=config,
+        transport=mock_transport,
+        interceptors=[mock_interceptor],
+    )
+
+
+class TestBaseClientInterceptors:
+    @pytest.mark.asyncio
+    async def test_execute_with_interceptors_normal_flow(
+        self,
+        base_client: BaseClient,
+        mock_interceptor: AsyncMock,
+    ):
+        input_data = MagicMock()
+        method = 'get_task'
+        context = MagicMock()
+        mock_transport_call = AsyncMock(return_value='transport_result')
+
+        # Set up mock interceptor to just pass through
+        mock_interceptor.before.return_value = None
+
+        result = await base_client._execute_with_interceptors(
+            input_data=input_data,
+            method=method,
+            context=context,
+            transport_call=mock_transport_call,
+        )
+
+        assert result == 'transport_result'
+
+        # Verify before was called
+        mock_interceptor.before.assert_called_once()
+        before_args = mock_interceptor.before.call_args[0][0]
+        assert isinstance(before_args, BeforeArgs)
+        assert before_args.input == input_data
+        assert before_args.context == context
+
+        # Verify transport call was made
+        mock_transport_call.assert_called_once_with(input_data, context)
+
+        # Verify after was called
+        mock_interceptor.after.assert_called_once()
+        after_args = mock_interceptor.after.call_args[0][0]
+        assert isinstance(after_args, AfterArgs)
+        assert after_args.method == method
+        assert after_args.result == 'transport_result'
+        assert after_args.context == context
+
+    @pytest.mark.asyncio
+    async def test_execute_with_interceptors_early_return(
+        self,
+        base_client: BaseClient,
+        mock_interceptor: AsyncMock,
+    ):
+        input_data = MagicMock()
+        method = 'get_task'
+        context = MagicMock()
+        mock_transport_call = AsyncMock()
+
+        # Set up early return in before
+        early_return_result = 'early_result'
+
+        async def mock_before_with_early_return(args: BeforeArgs):
+            args.early_return = early_return_result
+
+        mock_interceptor.before.side_effect = mock_before_with_early_return
+
+        result = await base_client._execute_with_interceptors(
+            input_data=input_data,
+            method=method,
+            context=context,
+            transport_call=mock_transport_call,
+        )
+
+        assert result == 'early_result'
+
+        # Verify before was called
+        mock_interceptor.before.assert_called_once()
+
+        # Verify transport call was NOT made
+        mock_transport_call.assert_not_called()
+
+        # Verify after was called with early return value
+        mock_interceptor.after.assert_called_once()
+        after_args = mock_interceptor.after.call_args[0][0]
+        assert isinstance(after_args, AfterArgs)
+        assert after_args.result == 'early_result'
+        assert after_args.context == context
+
+    @pytest.mark.asyncio
+    async def test_execute_stream_with_interceptors_normal_flow(
+        self,
+        base_client: BaseClient,
+        mock_interceptor: AsyncMock,
+    ):
+        input_data = MagicMock()
+        method = 'send_message_streaming'
+        context = MagicMock()
+
+        async def mock_transport_call(*args, **kwargs):
+            yield StreamResponse(message=Message(message_id='1'))
+
+        # Set up mock interceptor to just pass through
+        mock_interceptor.before.return_value = None
+
+        events = [
+            e
+            async for e in base_client._execute_stream_with_interceptors(
+                input_data=input_data,
+                method=method,
+                context=context,
+                transport_call=mock_transport_call,
+            )
+        ]
+
+        assert len(events) == 1
+
+        # Verify before was called
+        mock_interceptor.before.assert_called_once()
+        before_args = mock_interceptor.before.call_args[0][0]
+        assert isinstance(before_args, BeforeArgs)
+        assert before_args.input == input_data
+        assert before_args.context == context
+
+        # Verify after was called
+        mock_interceptor.after.assert_called_once()
+        after_args = mock_interceptor.after.call_args[0][0]
+        assert isinstance(after_args, AfterArgs)
+        assert after_args.method == method
+
+    @pytest.mark.asyncio
+    async def test_execute_stream_with_interceptors_early_return(
+        self,
+        base_client: BaseClient,
+        mock_interceptor: AsyncMock,
+    ):
+        input_data = MagicMock()
+        method = 'send_message_streaming'
+        context = MagicMock()
+        mock_transport_call = AsyncMock()
+
+        # Set up early return in before
+        early_return_result = StreamResponse(message=Message(message_id='2'))
+
+        async def mock_before_with_early_return(args: BeforeArgs):
+            args.early_return = early_return_result
+            return {
+                'early_return': early_return_result,
+                'executed': [mock_interceptor],
+            }
+
+        mock_interceptor.before.side_effect = mock_before_with_early_return
+
+        # Override BaseClient's _intercept_before to respect our early return setup
+        # as the test's mock interceptor replaces the actual list items
+        base_client._intercept_before = AsyncMock(  # type: ignore
+            return_value={
+                'early_return': early_return_result,
+                'executed': [mock_interceptor],
+            }
+        )
+
+        events = [
+            e
+            async for e in base_client._execute_stream_with_interceptors(
+                input_data=input_data,
+                method=method,
+                context=context,
+                transport_call=mock_transport_call,
+            )
+        ]
+
+        assert len(events) == 1
+
+        # Verify transport call was NOT made
+        mock_transport_call.assert_not_called()
+
+        # Verify after was called with early return value
+        mock_interceptor.after.assert_called_once()
+        after_args = mock_interceptor.after.call_args[0][0]
+        assert isinstance(after_args, AfterArgs)
+        assert after_args.method == method
+        assert after_args.context == context
diff --git a/tests/client/test_base_client_plugins.py b/tests/client/test_base_client_plugins.py
new file mode 100644
index 000000000..2704f9291
--- /dev/null
+++ b/tests/client/test_base_client_plugins.py
@@ -0,0 +1,388 @@
+from typing import Any
+from unittest.mock import AsyncMock
+
+import httpx
+import pytest
+
+from a2a import plugins
+from a2a.client.base_client import BaseClient
+from a2a.client.client import ClientCallContext, ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.client.interceptors import AfterArgs, BeforeArgs, ClientCallInterceptor
+from a2a.client.transports.base import ClientTransport
+from a2a.plugins import ClientRequest, ClientResponse
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+
+class Recorder(plugins.ClientPlugin):
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, Any]] = []
+
+    def hooks(self, name: str) -> list[Any]:
+        return [arg for hook, arg in self.calls if hook == name]
+
+    async def before_client_request(self, request: ClientRequest) -> None:
+        params = dict(request.context.service_parameters or {})
+        params['x-trace'] = 'abc'
+        request.context.service_parameters = params
+        self.calls.append(('before_client_request', request))
+
+    async def after_client_request(self, response: ClientResponse) -> None:
+        self.calls.append(('after_client_request', response))
+
+
+def card(streaming: bool = True) -> AgentCard:
+    return AgentCard(
+        name='Remote',
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=streaming),
+        supported_interfaces=[
+            AgentInterface(url='http://remote:9000', protocol_binding='JSONRPC')
+        ],
+    )
+
+
+def client(
+    recorder: Recorder | None,
+    transport: AsyncMock,
+    interceptors: list[ClientCallInterceptor] | None = None,
+    streaming: bool = True,
+) -> BaseClient:
+    return BaseClient(
+        card(streaming),
+        ClientConfig(streaming=streaming),
+        transport,
+        interceptors or [],
+        plugins=plugins.sequential(recorder) if recorder else None,
+    )
+
+
+def send_request() -> SendMessageRequest:
+    return SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='m-1', parts=[Part(text='hi')]
+        )
+    )
+
+
+def status_event(state: TaskState) -> StreamResponse:
+    return StreamResponse(
+        status_update=TaskStatusUpdateEvent(
+            task_id='t-1', status=TaskStatus(state=state)
+        )
+    )
+
+
+@pytest.fixture(autouse=True)
+def restore_global():
+    previous = plugins.get_global()
+    yield
+    plugins.set_global(previous)
+
+
+@pytest.mark.asyncio
+async def test_unary_call_runs_hooks():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+    transport.get_task.return_value = Task(id='t-1')
+
+    result = await client(recorder, transport).get_task(
+        GetTaskRequest(id='t-1')
+    )
+
+    assert result.id == 't-1'
+    (request,) = recorder.hooks('before_client_request')
+    assert request.method == 'get_task'
+    assert request.agent_card.name == 'Remote'
+    (response,) = recorder.hooks('after_client_request')
+    assert response.payload is result
+    assert response.is_final
+    assert response.context is request.context
+    # The header added by the plugin reaches the transport.
+    sent_context = transport.get_task.call_args.kwargs['context']
+    assert sent_context.service_parameters['x-trace'] == 'abc'
+
+
+@pytest.mark.asyncio
+async def test_non_streaming_send_message_is_a_unary_call():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+    transport.send_message.return_value = SendMessageResponse(
+        task=Task(id='t-1')
+    )
+
+    events = [
+        e
+        async for e in client(
+            recorder, transport, streaming=False
+        ).send_message(send_request())
+    ]
+
+    assert len(events) == 1
+    assert recorder.hooks('before_client_request')[0].method == 'send_message'
+    (response,) = recorder.hooks('after_client_request')
+    assert response.is_final
+
+
+@pytest.mark.asyncio
+async def test_streaming_reports_events_and_final_call():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+    streamed = [
+        status_event(TaskState.TASK_STATE_WORKING),
+        status_event(TaskState.TASK_STATE_COMPLETED),
+    ]
+
+    async def stream(request, *, context=None):
+        for e in streamed:
+            yield e
+
+    transport.send_message_streaming = stream
+
+    events = [
+        e
+        async for e in client(recorder, transport).send_message(send_request())
+    ]
+
+    assert events == streamed
+    (request,) = recorder.hooks('before_client_request')
+    assert request.method == 'send_message_streaming'
+    responses = recorder.hooks('after_client_request')
+    assert [r.payload for r in responses[:-1]] == streamed
+    assert all(r.is_stream_event and not r.is_final for r in responses[:-1])
+    assert responses[-1].is_final
+    assert responses[-1].payload is None
+    assert responses[-1].error is None
+
+
+@pytest.mark.asyncio
+async def test_stream_stopped_early_gets_final_call():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+
+    async def stream(request, *, context=None):
+        for _ in range(10):
+            yield status_event(TaskState.TASK_STATE_WORKING)
+
+    transport.send_message_streaming = stream
+    events = client(recorder, transport).send_message(send_request())
+    await anext(events)
+    await events.aclose()
+
+    assert recorder.hooks('after_client_request')[-1].is_final
+
+
+@pytest.mark.asyncio
+async def test_transport_errors_reach_after_client_request():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+    transport.get_task.side_effect = ConnectionError('down')
+
+    with pytest.raises(ConnectionError):
+        await client(recorder, transport).get_task(GetTaskRequest(id='t-1'))
+
+    (response,) = recorder.hooks('after_client_request')
+    assert isinstance(response.error, ConnectionError)
+
+    async def failing(request, *, context=None):
+        yield status_event(TaskState.TASK_STATE_WORKING)
+        raise ConnectionError('dropped')
+
+    transport.send_message_streaming = failing
+    recorder.calls.clear()
+    with pytest.raises(ConnectionError):
+        async for _ in client(recorder, transport).send_message(send_request()):
+            pass
+    assert isinstance(
+        recorder.hooks('after_client_request')[-1].error, ConnectionError
+    )
+
+
+@pytest.mark.asyncio
+async def test_plugins_wrap_interceptors_including_early_return():
+    order: list[str] = []
+
+    class Order(plugins.ClientPlugin):
+        async def before_client_request(self, request):
+            order.append('plugin.before')
+
+        async def after_client_request(self, response):
+            order.append('plugin.after')
+
+    class Cached(ClientCallInterceptor):
+        async def before(self, args: BeforeArgs) -> None:
+            order.append('interceptor.before')
+            args.early_return = Task(id='cached')
+
+        async def after(self, args: AfterArgs) -> None:
+            order.append('interceptor.after')
+
+    transport = AsyncMock(spec=ClientTransport)
+    c = BaseClient(
+        card(),
+        ClientConfig(),
+        transport,
+        [Cached()],
+        plugins=plugins.sequential(Order()),
+    )
+
+    result = await c.get_task(GetTaskRequest(id='t-1'))
+
+    assert result.id == 'cached'
+    transport.get_task.assert_not_called()
+    assert order == [
+        'plugin.before',
+        'interceptor.before',
+        'interceptor.after',
+        'plugin.after',
+    ]
+
+
+@pytest.mark.asyncio
+async def test_before_client_request_can_cancel_the_call():
+    class Deny(plugins.ClientPlugin):
+        async def before_client_request(self, request):
+            raise PermissionError('no')
+
+    transport = AsyncMock(spec=ClientTransport)
+    c = BaseClient(
+        card(),
+        ClientConfig(),
+        transport,
+        [],
+        plugins=plugins.sequential(Deny()),
+    )
+
+    with pytest.raises(PermissionError):
+        await c.get_task(GetTaskRequest(id='t-1'))
+    with pytest.raises(PermissionError):
+        async for _ in c.send_message(send_request()):
+            pass
+    transport.get_task.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_existing_context_is_passed_through():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+    transport.get_task.return_value = Task(id='t-1')
+    context = ClientCallContext(state={'k': 'v'})
+
+    await client(recorder, transport).get_task(
+        GetTaskRequest(id='t-1'), context=context
+    )
+
+    assert recorder.hooks('before_client_request')[0].context is context
+
+
+@pytest.mark.asyncio
+async def test_no_plugins_keeps_context_none():
+    transport = AsyncMock(spec=ClientTransport)
+    transport.get_task.return_value = Task(id='t-1')
+
+    await client(None, transport).get_task(GetTaskRequest(id='t-1'))
+
+    assert transport.get_task.call_args.kwargs['context'] is None
+
+
+def test_factory_clients_use_the_global_manager():
+    manager = plugins.sequential(Recorder())
+    plugins.set_global(manager)
+
+    c = ClientFactory(ClientConfig(httpx_client=httpx.AsyncClient())).create(
+        card()
+    )
+
+    assert isinstance(c, BaseClient)
+    assert c._plugins is manager
+
+
+@pytest.mark.parametrize(
+    ('call', 'method'),
+    [
+        (lambda c: c.list_tasks(ListTasksRequest()), 'list_tasks'),
+        (lambda c: c.cancel_task(CancelTaskRequest(id='t-1')), 'cancel_task'),
+        (
+            lambda c: c.create_task_push_notification_config(
+                TaskPushNotificationConfig(task_id='t-1', url='http://hook')
+            ),
+            'create_task_push_notification_config',
+        ),
+        (
+            lambda c: c.get_task_push_notification_config(
+                GetTaskPushNotificationConfigRequest(task_id='t-1', id='c-1')
+            ),
+            'get_task_push_notification_config',
+        ),
+        (
+            lambda c: c.list_task_push_notification_configs(
+                ListTaskPushNotificationConfigsRequest(task_id='t-1')
+            ),
+            'list_task_push_notification_configs',
+        ),
+        (
+            lambda c: c.delete_task_push_notification_config(
+                DeleteTaskPushNotificationConfigRequest(task_id='t-1', id='c-1')
+            ),
+            'delete_task_push_notification_config',
+        ),
+        (
+            lambda c: c.get_extended_agent_card(GetExtendedAgentCardRequest()),
+            'get_extended_agent_card',
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_unary_methods_report_method_names(call, method):
+    recorder = Recorder()
+
+    await call(client(recorder, AsyncMock(spec=ClientTransport)))
+
+    assert [r.method for r in recorder.hooks('before_client_request')] == [
+        method
+    ]
+    assert recorder.hooks('after_client_request')[-1].method == method
+
+
+@pytest.mark.asyncio
+async def test_subscribe_reports_method_name():
+    recorder = Recorder()
+    transport = AsyncMock(spec=ClientTransport)
+
+    async def stream(request, *, context=None):
+        yield status_event(TaskState.TASK_STATE_WORKING)
+
+    transport.subscribe = stream
+
+    async for _ in client(recorder, transport).subscribe(
+        SubscribeToTaskRequest(id='t-1')
+    ):
+        pass
+
+    assert recorder.hooks('before_client_request')[0].method == 'subscribe'
+    assert all(
+        r.method == 'subscribe' for r in recorder.hooks('after_client_request')
+    )
diff --git a/tests/client/test_card_resolver.py b/tests/client/test_card_resolver.py
new file mode 100644
index 000000000..a96402542
--- /dev/null
+++ b/tests/client/test_card_resolver.py
@@ -0,0 +1,1161 @@
+import copy
+import difflib
+import json
+import logging
+
+from unittest.mock import AsyncMock, MagicMock, Mock
+
+import httpx
+import pytest
+
+from a2a.client import A2ACardResolver, AgentCardResolutionError
+from a2a.client.card_resolver import parse_agent_card
+from a2a.server.request_handlers.response_helpers import agent_card_to_dict
+from a2a.types import AgentCard
+from a2a.types.a2a_pb2 import (
+    APIKeySecurityScheme,
+    AgentCapabilities,
+    AgentCardSignature,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+    AuthorizationCodeOAuthFlow,
+    HTTPAuthSecurityScheme,
+    MutualTlsSecurityScheme,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    OpenIdConnectSecurityScheme,
+    SecurityRequirement,
+    SecurityScheme,
+    StringList,
+)
+from a2a.utils import AGENT_CARD_WELL_KNOWN_PATH
+from google.protobuf.json_format import ParseError
+
+
+@pytest.fixture
+def mock_httpx_client():
+    """Fixture providing a mocked async httpx client."""
+    return AsyncMock(spec=httpx.AsyncClient)
+
+
+@pytest.fixture
+def base_url():
+    """Fixture providing a test base URL."""
+    return 'https://example.com'
+
+
+@pytest.fixture
+def resolver(mock_httpx_client, base_url):
+    """Fixture providing an A2ACardResolver instance."""
+    return A2ACardResolver(
+        httpx_client=mock_httpx_client,
+        base_url=base_url,
+    )
+
+
+@pytest.fixture
+def mock_response():
+    """Fixture providing a mock httpx Response."""
+    response = Mock(spec=httpx.Response)
+    response.raise_for_status = Mock()
+    return response
+
+
+@pytest.fixture
+def valid_agent_card_data():
+    """Fixture providing valid agent card data."""
+    return {
+        'name': 'TestAgent',
+        'description': 'A test agent',
+        'version': '1.0.0',
+        'supported_interfaces': [
+            {
+                'url': 'https://example.com/a2a',
+                'protocol_binding': 'HTTP+JSON',
+            }
+        ],
+        'capabilities': {},
+        'default_input_modes': ['text/plain'],
+        'default_output_modes': ['text/plain'],
+        'skills': [
+            {
+                'id': 'test-skill',
+                'name': 'Test Skill',
+                'description': 'A skill for testing',
+                'tags': ['test'],
+            }
+        ],
+    }
+
+
+class TestA2ACardResolverInit:
+    """Tests for A2ACardResolver initialization."""
+
+    def test_init_with_defaults(self, mock_httpx_client, base_url):
+        """Test initialization with default agent_card_path."""
+        resolver = A2ACardResolver(
+            httpx_client=mock_httpx_client,
+            base_url=base_url,
+        )
+        assert resolver.base_url == base_url
+        assert resolver.agent_card_path == AGENT_CARD_WELL_KNOWN_PATH[1:]
+        assert resolver.httpx_client == mock_httpx_client
+
+    def test_init_with_custom_path(self, mock_httpx_client, base_url):
+        """Test initialization with custom agent_card_path."""
+        custom_path = '/custom/agent/card'
+        resolver = A2ACardResolver(
+            httpx_client=mock_httpx_client,
+            base_url=base_url,
+            agent_card_path=custom_path,
+        )
+        assert resolver.base_url == base_url
+        assert resolver.agent_card_path == custom_path[1:]
+
+    def test_init_strips_leading_slash_from_agent_card_path(
+        self, mock_httpx_client, base_url
+    ):
+        """Test that leading slash is stripped from agent_card_path."""
+        agent_card_path = '/well-known/agent'
+        resolver = A2ACardResolver(
+            httpx_client=mock_httpx_client,
+            base_url=base_url,
+            agent_card_path=agent_card_path,
+        )
+        assert resolver.agent_card_path == agent_card_path[1:]
+
+
+class TestGetAgentCard:
+    """Tests for get_agent_card methods."""
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_success_default_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test successful agent card fetch using default path."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+
+        result = await resolver.get_agent_card()
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}',
+        )
+        mock_response.raise_for_status.assert_called_once()
+        mock_response.json.assert_called_once()
+        assert result is not None
+        assert isinstance(result, AgentCard)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_success_custom_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test successful agent card fetch using custom relative path."""
+        custom_path = 'custom/path/card'
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        await resolver.get_agent_card(relative_card_path=custom_path)
+
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{custom_path}',
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_strips_leading_slash_from_relative_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test successful agent card fetch using custom path with leading slash."""
+        custom_path = '/custom/path/card'
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        await resolver.get_agent_card(relative_card_path=custom_path)
+
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{custom_path[1:]}',
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_with_http_kwargs(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test that http_kwargs are passed to httpx.get."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        http_kwargs = {
+            'timeout': 30,
+            'headers': {'Authorization': 'Bearer token'},
+        }
+        await resolver.get_agent_card(http_kwargs=http_kwargs)
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}',
+            timeout=30,
+            headers={'Authorization': 'Bearer token'},
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_root_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test fetching agent card from root path."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        await resolver.get_agent_card(relative_card_path='/')
+        mock_httpx_client.get.assert_called_once_with(f'{base_url}')
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_with_empty_resolver_agent_card_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test fetching agent card when the resolver's agent_card_path is empty."""
+        resolver.agent_card_path = ''
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        await resolver.get_agent_card()
+        mock_httpx_client.get.assert_called_once_with(f'{base_url}')
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_http_status_error(
+        self, resolver, mock_httpx_client
+    ):
+        """Test A2AClientHTTPError raised on HTTP status error."""
+        status_code = 404
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = status_code
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            'Not Found', request=Mock(), response=mock_response
+        )
+        mock_httpx_client.get.return_value = mock_response
+
+        with pytest.raises(AgentCardResolutionError) as exc_info:
+            await resolver.get_agent_card()
+
+        assert exc_info.value.status_code == status_code
+        assert f'HTTP {status_code}' in str(exc_info.value)
+        assert 'Failed to fetch agent card' in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_json_decode_error(
+        self, resolver, mock_httpx_client, mock_response
+    ):
+        """Test A2AClientJSONError raised on JSON decode error."""
+        mock_response.json.side_effect = json.JSONDecodeError(
+            'Invalid JSON', '', 0
+        )
+        mock_httpx_client.get.return_value = mock_response
+        with pytest.raises(AgentCardResolutionError) as exc_info:
+            await resolver.get_agent_card()
+        assert 'Failed to parse JSON' in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_request_error(
+        self, resolver, mock_httpx_client
+    ):
+        """Test A2AClientHTTPError raised on network request error."""
+        mock_httpx_client.get.side_effect = httpx.RequestError(
+            'Connection timeout', request=Mock()
+        )
+        with pytest.raises(AgentCardResolutionError) as exc_info:
+            await resolver.get_agent_card()
+        assert 'Network communication error' in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_validation_error(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test A2AClientJSONError is raised on agent card validation error."""
+        return_json = {'name': {'invalid': 'type'}}
+        mock_response.json.return_value = return_json
+        mock_httpx_client.get.return_value = mock_response
+        with pytest.raises(AgentCardResolutionError) as exc_info:
+            await resolver.get_agent_card()
+        assert (
+            f'Failed to validate agent card structure from {base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}'
+            in str(exc_info.value)
+        )
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}',
+        )
+
+    @pytest.mark.parametrize(
+        'response_body',
+        [
+            'null',
+            '[]',
+            '[{"name":"TestAgent"}]',
+            '"TestAgent"',
+            '42',
+            '1.5',
+            'true',
+            'false',
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_get_agent_card_non_object_json(
+        self, response_body: str
+    ) -> None:
+        """Non-object JSON responses use the documented resolution error."""
+        transport = httpx.MockTransport(
+            lambda _request: httpx.Response(200, content=response_body)
+        )
+        async with httpx.AsyncClient(transport=transport) as client:
+            resolver = A2ACardResolver(client, 'https://example.com')
+            with pytest.raises(AgentCardResolutionError) as exc_info:
+                await resolver.get_agent_card()
+
+        assert 'Failed to validate agent card structure' in str(exc_info.value)
+        assert isinstance(exc_info.value.__cause__, ParseError)
+
+    @pytest.mark.parametrize(
+        ('response_body', 'original_error'),
+        [
+            pytest.param(
+                '{"supportsAuthenticatedExtendedCard":true,"capabilities":null}',
+                TypeError,
+                id='null-capabilities',
+            ),
+            pytest.param(
+                '{"supportsAuthenticatedExtendedCard":true,"capabilities":[]}',
+                TypeError,
+                id='list-capabilities',
+            ),
+            pytest.param(
+                '{"url":"https://example.com","additionalInterfaces":[null]}',
+                AttributeError,
+                id='null-interface',
+            ),
+            pytest.param('{"skills":null}', TypeError, id='null-skills'),
+            pytest.param('{"skills":[null]}', AttributeError, id='null-skill'),
+            pytest.param(
+                '{"security":"invalid"}', AttributeError, id='string-security'
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_get_agent_card_malformed_nested_fields(
+        self, response_body: str, original_error: type[Exception]
+    ) -> None:
+        """Malformed legacy fields preserve the documented error chain."""
+        transport = httpx.MockTransport(
+            lambda _request: httpx.Response(200, content=response_body)
+        )
+        async with httpx.AsyncClient(transport=transport) as client:
+            resolver = A2ACardResolver(client, 'https://example.com')
+            with pytest.raises(AgentCardResolutionError) as exc_info:
+                await resolver.get_agent_card()
+
+        assert 'Failed to validate agent card structure' in str(exc_info.value)
+        parse_error = exc_info.value.__cause__
+        assert isinstance(parse_error, ParseError)
+        assert isinstance(parse_error.__cause__, original_error)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_logs_success(  # noqa: PLR0913
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+        caplog,
+    ):
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        with caplog.at_level(logging.INFO):
+            await resolver.get_agent_card()
+        assert (
+            f'Successfully fetched agent card data from {base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}'
+            in caplog.text
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_none_relative_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test that None relative_card_path uses default path."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+
+        await resolver.get_agent_card(relative_card_path=None)
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}',
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_empty_string_relative_path(
+        self,
+        base_url,
+        resolver,
+        mock_httpx_client,
+        mock_response,
+        valid_agent_card_data,
+    ):
+        """Test that empty string relative_card_path uses default path."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+
+        await resolver.get_agent_card(relative_card_path='')
+
+        mock_httpx_client.get.assert_called_once_with(
+            f'{base_url}/{AGENT_CARD_WELL_KNOWN_PATH[1:]}',
+        )
+
+    @pytest.mark.parametrize('status_code', [400, 401, 403, 500, 502])
+    @pytest.mark.asyncio
+    async def test_get_agent_card_different_status_codes(
+        self, resolver, mock_httpx_client, status_code
+    ):
+        """Test different HTTP status codes raise appropriate errors."""
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = status_code
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            f'Status {status_code}', request=Mock(), response=mock_response
+        )
+        mock_httpx_client.get.return_value = mock_response
+        with pytest.raises(AgentCardResolutionError) as exc_info:
+            await resolver.get_agent_card()
+        assert f'HTTP {status_code}' in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_returns_agent_card_instance(
+        self, resolver, mock_httpx_client, mock_response, valid_agent_card_data
+    ):
+        """Test that get_agent_card returns an AgentCard instance."""
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+        result = await resolver.get_agent_card()
+        assert isinstance(result, AgentCard)
+        mock_response.raise_for_status.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_agent_card_with_signature_verifier(
+        self, resolver, mock_httpx_client, valid_agent_card_data
+    ):
+        """Test that the signature verifier is called if provided."""
+        mock_verifier = MagicMock()
+
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.json.return_value = valid_agent_card_data
+        mock_httpx_client.get.return_value = mock_response
+
+        agent_card = await resolver.get_agent_card(
+            signature_verifier=mock_verifier
+        )
+
+        mock_verifier.assert_called_once_with(agent_card)
+
+
+class TestParseAgentCard:
+    """Tests for parse_agent_card function."""
+
+    @staticmethod
+    def _assert_agent_card_diff(
+        original_data: dict, serialized_data: dict
+    ) -> None:
+        """Helper to assert that the re-serialized 1.0.0 JSON payload contains all original 0.3.0 data (no dropped fields)."""
+        original_json_str = json.dumps(original_data, indent=2, sort_keys=True)
+        serialized_json_str = json.dumps(
+            serialized_data, indent=2, sort_keys=True
+        )
+
+        diff_lines = list(
+            difflib.unified_diff(
+                original_json_str.splitlines(),
+                serialized_json_str.splitlines(),
+                lineterm='',
+            )
+        )
+
+        removed_lines = []
+        for line in diff_lines:
+            if line.startswith('-') and not line.startswith('---'):
+                removed_lines.append(line)
+
+        if removed_lines:
+            error_msg = (
+                'Re-serialization dropped fields from the original payload:\n'
+                + '\n'.join(removed_lines)
+            )
+            raise AssertionError(error_msg)
+
+    def test_parse_agent_card_legacy_support(self) -> None:
+        data = {
+            'name': 'Legacy Agent',
+            'description': 'Legacy Description',
+            'version': '1.0',
+            'supportsAuthenticatedExtendedCard': True,
+        }
+        card = parse_agent_card(data)
+        assert card.name == 'Legacy Agent'
+        assert card.capabilities.extended_agent_card is True
+        # Ensure it's popped from the dict
+        assert 'supportsAuthenticatedExtendedCard' not in data
+
+    def test_parse_agent_card_new_support(self) -> None:
+        data = {
+            'name': 'New Agent',
+            'description': 'New Description',
+            'version': '1.0',
+            'capabilities': {'extendedAgentCard': True},
+        }
+        card = parse_agent_card(data)
+        assert card.name == 'New Agent'
+        assert card.capabilities.extended_agent_card is True
+
+    def test_parse_agent_card_no_support(self) -> None:
+        data = {
+            'name': 'No Support Agent',
+            'description': 'No Support Description',
+            'version': '1.0',
+            'capabilities': {'extendedAgentCard': False},
+        }
+        card = parse_agent_card(data)
+        assert card.name == 'No Support Agent'
+        assert card.capabilities.extended_agent_card is False
+
+    def test_parse_agent_card_both_legacy_and_new(self) -> None:
+        data = {
+            'name': 'Mixed Agent',
+            'description': 'Mixed Description',
+            'version': '1.0',
+            'supportsAuthenticatedExtendedCard': True,
+            'capabilities': {'streaming': True},
+        }
+        card = parse_agent_card(data)
+        assert card.name == 'Mixed Agent'
+        assert card.capabilities.streaming is True
+        assert card.capabilities.extended_agent_card is True
+
+    def test_parse_typical_030_agent_card(self) -> None:
+        data = {
+            'additionalInterfaces': [
+                {
+                    'transport': 'GRPC',
+                    'url': 'http://agent.example.com/api/grpc',
+                }
+            ],
+            'capabilities': {'streaming': True},
+            'defaultInputModes': ['text/plain'],
+            'defaultOutputModes': ['application/json'],
+            'description': 'A typical agent from 0.3.0',
+            'name': 'Typical Agent 0.3',
+            'preferredTransport': 'JSONRPC',
+            'protocolVersion': '0.3.0',
+            'security': [{'test_oauth': ['read', 'write']}],
+            'securitySchemes': {
+                'test_oauth': {
+                    'description': 'OAuth2 authentication',
+                    'flows': {
+                        'authorizationCode': {
+                            'authorizationUrl': 'http://auth.example.com',
+                            'scopes': {
+                                'read': 'Read access',
+                                'write': 'Write access',
+                            },
+                            'tokenUrl': 'http://token.example.com',
+                        }
+                    },
+                    'type': 'oauth2',
+                }
+            },
+            'skills': [
+                {
+                    'description': 'The first skill',
+                    'id': 'skill-1',
+                    'name': 'Skill 1',
+                    'security': [{'test_oauth': ['read']}],
+                    'tags': ['example'],
+                }
+            ],
+            'supportsAuthenticatedExtendedCard': True,
+            'url': 'http://agent.example.com/api',
+            'version': '1.0',
+        }
+        original_data = copy.deepcopy(data)
+        card = parse_agent_card(data)
+
+        expected_card = AgentCard(
+            name='Typical Agent 0.3',
+            description='A typical agent from 0.3.0',
+            version='1.0',
+            capabilities=AgentCapabilities(
+                extended_agent_card=True, streaming=True
+            ),
+            default_input_modes=['text/plain'],
+            default_output_modes=['application/json'],
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://agent.example.com/api',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3.0',
+                ),
+                AgentInterface(
+                    url='http://agent.example.com/api/grpc',
+                    protocol_binding='GRPC',
+                    protocol_version='0.3.0',
+                ),
+            ],
+            security_requirements=[
+                SecurityRequirement(
+                    schemes={'test_oauth': StringList(list=['read', 'write'])}
+                )
+            ],
+            security_schemes={
+                'test_oauth': SecurityScheme(
+                    oauth2_security_scheme=OAuth2SecurityScheme(
+                        description='OAuth2 authentication',
+                        flows=OAuthFlows(
+                            authorization_code=AuthorizationCodeOAuthFlow(
+                                authorization_url='http://auth.example.com',
+                                token_url='http://token.example.com',
+                                scopes={
+                                    'read': 'Read access',
+                                    'write': 'Write access',
+                                },
+                            )
+                        ),
+                    )
+                )
+            },
+            skills=[
+                AgentSkill(
+                    id='skill-1',
+                    name='Skill 1',
+                    description='The first skill',
+                    tags=['example'],
+                    security_requirements=[
+                        SecurityRequirement(
+                            schemes={'test_oauth': StringList(list=['read'])}
+                        )
+                    ],
+                )
+            ],
+        )
+
+        assert card == expected_card
+
+        # Serialize back to JSON and compare
+        serialized_data = agent_card_to_dict(card)
+
+        self._assert_agent_card_diff(original_data, serialized_data)
+        assert 'preferredTransport' in serialized_data
+
+        # Re-parse from the serialized payload and verify identical to original parsing
+        re_parsed_card = parse_agent_card(copy.deepcopy(serialized_data))
+        assert re_parsed_card == card
+
+    def test_parse_agent_card_security_scheme_without_in(self) -> None:
+        data = {
+            'name': 'API Key Agent',
+            'description': 'API Key without in param',
+            'version': '1.0',
+            'securitySchemes': {
+                'test_api_key': {'type': 'apiKey', 'name': 'X-API-KEY'}
+            },
+        }
+        card = parse_agent_card(data)
+        assert 'test_api_key' in card.security_schemes
+        assert (
+            card.security_schemes['test_api_key'].api_key_security_scheme.name
+            == 'X-API-KEY'
+        )
+        assert (
+            card.security_schemes[
+                'test_api_key'
+            ].api_key_security_scheme.location
+            == ''
+        )
+
+    def test_parse_agent_card_security_scheme_unknown_type(self) -> None:
+        data = {
+            'name': 'Unknown Scheme Agent',
+            'description': 'Has unknown scheme type',
+            'version': '1.0',
+            'securitySchemes': {
+                'test_unknown': {
+                    'type': 'someFutureType',
+                    'future_prop': 'value',
+                },
+                'test_missing_type': {'prop': 'value'},
+            },
+        }
+        card = parse_agent_card(data)
+        assert 'test_unknown' in card.security_schemes
+        assert not card.security_schemes['test_unknown'].WhichOneof('scheme')
+
+        assert 'test_missing_type' in card.security_schemes
+        assert not card.security_schemes['test_missing_type'].WhichOneof(
+            'scheme'
+        )
+
+    def test_parse_030_agent_card_route_planner(self) -> None:
+        data = {
+            'protocolVersion': '0.3',
+            'name': 'GeoSpatial Route Planner Agent',
+            'description': 'Provides advanced route planning.',
+            'url': 'https://georoute-agent.example.com/a2a/v1',
+            'preferredTransport': 'JSONRPC',
+            'additionalInterfaces': [
+                {
+                    'url': 'https://georoute-agent.example.com/a2a/v1',
+                    'transport': 'JSONRPC',
+                },
+                {
+                    'url': 'https://georoute-agent.example.com/a2a/grpc',
+                    'transport': 'GRPC',
+                },
+                {
+                    'url': 'https://georoute-agent.example.com/a2a/json',
+                    'transport': 'HTTP+JSON',
+                },
+            ],
+            'provider': {
+                'organization': 'Example Geo Services Inc.',
+                'url': 'https://www.examplegeoservices.com',
+            },
+            'iconUrl': 'https://georoute-agent.example.com/icon.png',
+            'version': '1.2.0',
+            'documentationUrl': 'https://docs.examplegeoservices.com/georoute-agent/api',
+            'supportsAuthenticatedExtendedCard': True,
+            'capabilities': {
+                'streaming': True,
+                'pushNotifications': True,
+                'stateTransitionHistory': False,
+            },
+            'securitySchemes': {
+                'google': {
+                    'type': 'openIdConnect',
+                    'openIdConnectUrl': 'https://accounts.google.com/.well-known/openid-configuration',
+                }
+            },
+            'security': [{'google': ['openid', 'profile', 'email']}],
+            'defaultInputModes': ['application/json', 'text/plain'],
+            'defaultOutputModes': ['application/json', 'image/png'],
+            'skills': [
+                {
+                    'id': 'route-optimizer-traffic',
+                    'name': 'Traffic-Aware Route Optimizer',
+                    'description': 'Calculates the optimal driving route between two or more locations, taking into account real-time traffic conditions, road closures, and user preferences (e.g., avoid tolls, prefer highways).',
+                    'tags': [
+                        'maps',
+                        'routing',
+                        'navigation',
+                        'directions',
+                        'traffic',
+                    ],
+                    'examples': [
+                        "Plan a route from '1600 Amphitheatre Parkway, Mountain View, CA' to 'San Francisco International Airport' avoiding tolls.",
+                        '{"origin": {"lat": 37.422, "lng": -122.084}, "destination": {"lat": 37.7749, "lng": -122.4194}, "preferences": ["avoid_ferries"]}',
+                    ],
+                    'inputModes': ['application/json', 'text/plain'],
+                    'outputModes': [
+                        'application/json',
+                        'application/vnd.geo+json',
+                        'text/html',
+                    ],
+                    'security': [
+                        {'example': []},
+                        {'google': ['openid', 'profile', 'email']},
+                    ],
+                },
+                {
+                    'id': 'custom-map-generator',
+                    'name': 'Personalized Map Generator',
+                    'description': 'Creates custom map images or interactive map views based on user-defined points of interest, routes, and style preferences. Can overlay data layers.',
+                    'tags': [
+                        'maps',
+                        'customization',
+                        'visualization',
+                        'cartography',
+                    ],
+                    'examples': [
+                        'Generate a map of my upcoming road trip with all planned stops highlighted.',
+                        'Show me a map visualizing all coffee shops within a 1-mile radius of my current location.',
+                    ],
+                    'inputModes': ['application/json'],
+                    'outputModes': [
+                        'image/png',
+                        'image/jpeg',
+                        'application/json',
+                        'text/html',
+                    ],
+                },
+            ],
+            'signatures': [
+                {
+                    'protected': 'eyJhbGciOiJFUzI1NiIsInR5cCI6IkpPU0UiLCJraWQiOiJrZXktMSIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYWdlbnQvandrcy5qc29uIn0',
+                    'signature': 'QFdkNLNszlGj3z3u0YQGt_T9LixY3qtdQpZmsTdDHDe3fXV9y9-B3m2-XgCpzuhiLt8E0tV6HXoZKHv4GtHgKQ',
+                }
+            ],
+        }
+
+        original_data = copy.deepcopy(data)
+        card = parse_agent_card(data)
+
+        expected_card = AgentCard(
+            name='GeoSpatial Route Planner Agent',
+            description='Provides advanced route planning.',
+            version='1.2.0',
+            documentation_url='https://docs.examplegeoservices.com/georoute-agent/api',
+            icon_url='https://georoute-agent.example.com/icon.png',
+            provider=AgentProvider(
+                organization='Example Geo Services Inc.',
+                url='https://www.examplegeoservices.com',
+            ),
+            capabilities=AgentCapabilities(
+                extended_agent_card=True,
+                streaming=True,
+                push_notifications=True,
+            ),
+            default_input_modes=['application/json', 'text/plain'],
+            default_output_modes=['application/json', 'image/png'],
+            supported_interfaces=[
+                AgentInterface(
+                    url='https://georoute-agent.example.com/a2a/v1',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3',
+                ),
+                AgentInterface(
+                    url='https://georoute-agent.example.com/a2a/v1',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3',
+                ),
+                AgentInterface(
+                    url='https://georoute-agent.example.com/a2a/grpc',
+                    protocol_binding='GRPC',
+                    protocol_version='0.3',
+                ),
+                AgentInterface(
+                    url='https://georoute-agent.example.com/a2a/json',
+                    protocol_binding='HTTP+JSON',
+                    protocol_version='0.3',
+                ),
+            ],
+            security_requirements=[
+                SecurityRequirement(
+                    schemes={
+                        'google': StringList(
+                            list=['openid', 'profile', 'email']
+                        )
+                    }
+                )
+            ],
+            security_schemes={
+                'google': SecurityScheme(
+                    open_id_connect_security_scheme=OpenIdConnectSecurityScheme(
+                        open_id_connect_url='https://accounts.google.com/.well-known/openid-configuration'
+                    )
+                )
+            },
+            skills=[
+                AgentSkill(
+                    id='route-optimizer-traffic',
+                    name='Traffic-Aware Route Optimizer',
+                    description='Calculates the optimal driving route between two or more locations, taking into account real-time traffic conditions, road closures, and user preferences (e.g., avoid tolls, prefer highways).',
+                    tags=[
+                        'maps',
+                        'routing',
+                        'navigation',
+                        'directions',
+                        'traffic',
+                    ],
+                    examples=[
+                        "Plan a route from '1600 Amphitheatre Parkway, Mountain View, CA' to 'San Francisco International Airport' avoiding tolls.",
+                        '{"origin": {"lat": 37.422, "lng": -122.084}, "destination": {"lat": 37.7749, "lng": -122.4194}, "preferences": ["avoid_ferries"]}',
+                    ],
+                    input_modes=['application/json', 'text/plain'],
+                    output_modes=[
+                        'application/json',
+                        'application/vnd.geo+json',
+                        'text/html',
+                    ],
+                    security_requirements=[
+                        SecurityRequirement(schemes={'example': StringList()}),
+                        SecurityRequirement(
+                            schemes={
+                                'google': StringList(
+                                    list=['openid', 'profile', 'email']
+                                )
+                            }
+                        ),
+                    ],
+                ),
+                AgentSkill(
+                    id='custom-map-generator',
+                    name='Personalized Map Generator',
+                    description='Creates custom map images or interactive map views based on user-defined points of interest, routes, and style preferences. Can overlay data layers.',
+                    tags=[
+                        'maps',
+                        'customization',
+                        'visualization',
+                        'cartography',
+                    ],
+                    examples=[
+                        'Generate a map of my upcoming road trip with all planned stops highlighted.',
+                        'Show me a map visualizing all coffee shops within a 1-mile radius of my current location.',
+                    ],
+                    input_modes=['application/json'],
+                    output_modes=[
+                        'image/png',
+                        'image/jpeg',
+                        'application/json',
+                        'text/html',
+                    ],
+                ),
+            ],
+            signatures=[
+                AgentCardSignature(
+                    protected='eyJhbGciOiJFUzI1NiIsInR5cCI6IkpPU0UiLCJraWQiOiJrZXktMSIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYWdlbnQvandrcy5qc29uIn0',
+                    signature='QFdkNLNszlGj3z3u0YQGt_T9LixY3qtdQpZmsTdDHDe3fXV9y9-B3m2-XgCpzuhiLt8E0tV6HXoZKHv4GtHgKQ',
+                )
+            ],
+        )
+
+        assert card == expected_card
+        serialized_data = agent_card_to_dict(card)
+        del original_data['capabilities']['stateTransitionHistory']
+        self._assert_agent_card_diff(original_data, serialized_data)
+        re_parsed_card = parse_agent_card(copy.deepcopy(serialized_data))
+        assert re_parsed_card == card
+
+    def test_parse_complex_030_agent_card(self) -> None:
+        data = {
+            'additionalInterfaces': [
+                {
+                    'transport': 'GRPC',
+                    'url': 'http://complex.agent.example.com/grpc',
+                },
+                {
+                    'transport': 'JSONRPC',
+                    'url': 'http://complex.agent.example.com/jsonrpc',
+                },
+            ],
+            'capabilities': {'pushNotifications': True, 'streaming': True},
+            'defaultInputModes': ['text/plain', 'application/json'],
+            'defaultOutputModes': ['application/json', 'image/png'],
+            'description': 'A very complex agent from 0.3.0',
+            'name': 'Complex Agent 0.3',
+            'preferredTransport': 'HTTP+JSON',
+            'protocolVersion': '0.3.0',
+            'security': [
+                {'test_oauth': ['read', 'write'], 'test_api_key': []},
+                {'test_http': []},
+                {'test_oidc': ['openid', 'profile']},
+                {'test_mtls': []},
+            ],
+            'securitySchemes': {
+                'test_oauth': {
+                    'description': 'OAuth2 authentication',
+                    'flows': {
+                        'authorizationCode': {
+                            'authorizationUrl': 'http://auth.example.com',
+                            'scopes': {
+                                'read': 'Read access',
+                                'write': 'Write access',
+                            },
+                            'tokenUrl': 'http://token.example.com',
+                        }
+                    },
+                    'type': 'oauth2',
+                },
+                'test_api_key': {
+                    'description': 'API Key auth',
+                    'in': 'header',
+                    'name': 'X-API-KEY',
+                    'type': 'apiKey',
+                },
+                'test_http': {
+                    'bearerFormat': 'JWT',
+                    'description': 'HTTP Basic auth',
+                    'scheme': 'basic',
+                    'type': 'http',
+                },
+                'test_oidc': {
+                    'description': 'OIDC Auth',
+                    'openIdConnectUrl': 'https://example.com/.well-known/openid-configuration',
+                    'type': 'openIdConnect',
+                },
+                'test_mtls': {'description': 'mTLS Auth', 'type': 'mutualTLS'},
+            },
+            'skills': [
+                {
+                    'description': 'The first complex skill',
+                    'id': 'skill-1',
+                    'inputModes': ['application/json'],
+                    'name': 'Complex Skill 1',
+                    'outputModes': ['application/json'],
+                    'security': [{'test_api_key': []}],
+                    'tags': ['example', 'complex'],
+                },
+                {
+                    'description': 'The second complex skill',
+                    'id': 'skill-2',
+                    'name': 'Complex Skill 2',
+                    'security': [{'test_oidc': ['openid']}],
+                    'tags': ['example2'],
+                },
+            ],
+            'supportsAuthenticatedExtendedCard': True,
+            'url': 'http://complex.agent.example.com/api',
+            'version': '1.5.2',
+        }
+        original_data = copy.deepcopy(data)
+        card = parse_agent_card(data)
+
+        expected_card = AgentCard(
+            name='Complex Agent 0.3',
+            description='A very complex agent from 0.3.0',
+            version='1.5.2',
+            capabilities=AgentCapabilities(
+                extended_agent_card=True,
+                streaming=True,
+                push_notifications=True,
+            ),
+            default_input_modes=['text/plain', 'application/json'],
+            default_output_modes=['application/json', 'image/png'],
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://complex.agent.example.com/api',
+                    protocol_binding='HTTP+JSON',
+                    protocol_version='0.3.0',
+                ),
+                AgentInterface(
+                    url='http://complex.agent.example.com/grpc',
+                    protocol_binding='GRPC',
+                    protocol_version='0.3.0',
+                ),
+                AgentInterface(
+                    url='http://complex.agent.example.com/jsonrpc',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3.0',
+                ),
+            ],
+            security_requirements=[
+                SecurityRequirement(
+                    schemes={
+                        'test_oauth': StringList(list=['read', 'write']),
+                        'test_api_key': StringList(),
+                    }
+                ),
+                SecurityRequirement(schemes={'test_http': StringList()}),
+                SecurityRequirement(
+                    schemes={
+                        'test_oidc': StringList(list=['openid', 'profile'])
+                    }
+                ),
+                SecurityRequirement(schemes={'test_mtls': StringList()}),
+            ],
+            security_schemes={
+                'test_oauth': SecurityScheme(
+                    oauth2_security_scheme=OAuth2SecurityScheme(
+                        description='OAuth2 authentication',
+                        flows=OAuthFlows(
+                            authorization_code=AuthorizationCodeOAuthFlow(
+                                authorization_url='http://auth.example.com',
+                                token_url='http://token.example.com',
+                                scopes={
+                                    'read': 'Read access',
+                                    'write': 'Write access',
+                                },
+                            )
+                        ),
+                    )
+                ),
+                'test_api_key': SecurityScheme(
+                    api_key_security_scheme=APIKeySecurityScheme(
+                        description='API Key auth',
+                        location='header',
+                        name='X-API-KEY',
+                    )
+                ),
+                'test_http': SecurityScheme(
+                    http_auth_security_scheme=HTTPAuthSecurityScheme(
+                        description='HTTP Basic auth',
+                        scheme='basic',
+                        bearer_format='JWT',
+                    )
+                ),
+                'test_oidc': SecurityScheme(
+                    open_id_connect_security_scheme=OpenIdConnectSecurityScheme(
+                        description='OIDC Auth',
+                        open_id_connect_url='https://example.com/.well-known/openid-configuration',
+                    )
+                ),
+                'test_mtls': SecurityScheme(
+                    mtls_security_scheme=MutualTlsSecurityScheme(
+                        description='mTLS Auth'
+                    )
+                ),
+            },
+            skills=[
+                AgentSkill(
+                    id='skill-1',
+                    name='Complex Skill 1',
+                    description='The first complex skill',
+                    tags=['example', 'complex'],
+                    input_modes=['application/json'],
+                    output_modes=['application/json'],
+                    security_requirements=[
+                        SecurityRequirement(
+                            schemes={'test_api_key': StringList()}
+                        )
+                    ],
+                ),
+                AgentSkill(
+                    id='skill-2',
+                    name='Complex Skill 2',
+                    description='The second complex skill',
+                    tags=['example2'],
+                    security_requirements=[
+                        SecurityRequirement(
+                            schemes={'test_oidc': StringList(list=['openid'])}
+                        )
+                    ],
+                ),
+            ],
+        )
+
+        assert card == expected_card
+        serialized_data = agent_card_to_dict(card)
+        self._assert_agent_card_diff(original_data, serialized_data)
+        re_parsed_card = parse_agent_card(copy.deepcopy(serialized_data))
+        assert re_parsed_card == card
diff --git a/tests/client/test_client.py b/tests/client/test_client.py
deleted file mode 100644
index aedc8f107..000000000
--- a/tests/client/test_client.py
+++ /dev/null
@@ -1,637 +0,0 @@
-import json
-from unittest.mock import AsyncMock, MagicMock, patch
-from collections.abc import AsyncGenerator
-import httpx
-import pytest
-
-from a2a.client import (
-    A2ACardResolver,
-    A2AClient,
-    A2AClientHTTPError,
-    A2AClientJSONError,
-    create_text_message_object,
-)
-from a2a.types import (
-    AgentCard,
-    AgentSkill,
-    AgentCapabilities,
-    AgentAuthentication,
-    A2ARequest,
-    Role,
-    TaskQueryParams,
-    TaskIdParams,
-    GetTaskRequest,
-    GetTaskResponse,
-    SendMessageRequest,
-    MessageSendParams,
-    SendMessageResponse,
-    SendMessageSuccessResponse,
-    JSONRPCErrorResponse,
-    InvalidParamsError,
-    CancelTaskRequest,
-    CancelTaskResponse,
-    CancelTaskSuccessResponse,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
-    TaskNotCancelableError,
-)
-from typing import Any
-from httpx_sse import ServerSentEvent, EventSource
-
-
-AGENT_CARD = AgentCard(
-    name='Hello World Agent',
-    description='Just a hello world agent',
-    url='http://localhost:9999/',
-    version='1.0.0',
-    defaultInputModes=['text'],
-    defaultOutputModes=['text'],
-    capabilities=AgentCapabilities(),
-    skills=[
-        AgentSkill(
-            id='hello_world',
-            name='Returns hello world',
-            description='just returns hello world',
-            tags=['hello world'],
-            examples=['hi', 'hello world'],
-        )
-    ],
-    authentication=AgentAuthentication(schemes=['public']),
-)
-
-MINIMAL_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': {'state': 'working'},
-    'type': 'task',
-}
-
-MINIMAL_CANCELLED_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': {'state': 'canceled'},
-    'type': 'task',
-}
-
-
-@pytest.fixture
-def mock_httpx_client() -> AsyncMock:
-    return AsyncMock(spec=httpx.AsyncClient)
-
-
-@pytest.fixture
-def mock_agent_card() -> MagicMock:
-    return MagicMock(spec=AgentCard, url='http://agent.example.com/api')
-
-
-async def async_iterable_from_list(
-    items: list[ServerSentEvent],
-) -> AsyncGenerator[ServerSentEvent, None]:
-    """Helper to create an async iterable from a list."""
-    for item in items:
-        yield item
-
-
-class TestA2ACardResolver:
-    BASE_URL = 'http://example.com'
-    AGENT_CARD_PATH = '/.well-known/agent.json'
-    FULL_AGENT_CARD_URL = f'{BASE_URL}{AGENT_CARD_PATH}'
-
-    @pytest.mark.asyncio
-    async def test_init_strips_slashes(self, mock_httpx_client: AsyncMock):
-        resolver = A2ACardResolver(
-            httpx_client=mock_httpx_client,
-            base_url='http://example.com/',
-            agent_card_path='/.well-known/agent.json/',
-        )
-        assert resolver.base_url == 'http://example.com'
-        assert (
-            resolver.agent_card_path == '.well-known/agent.json/'
-        )  # Path is only lstrip'd
-
-        resolver_no_leading_slash_path = A2ACardResolver(
-            httpx_client=AsyncMock(),
-            base_url='http://example.com',
-            agent_card_path='.well-known/agent.json',
-        )
-        assert resolver_no_leading_slash_path.base_url == 'http://example.com'
-        assert (
-            resolver_no_leading_slash_path.agent_card_path
-            == '.well-known/agent.json'
-        )
-
-    @pytest.mark.asyncio
-    async def test_get_agent_card_success(self, mock_httpx_client: AsyncMock):
-        mock_response = AsyncMock(spec=httpx.Response)
-        mock_response.status_code = 200
-        mock_response.json.return_value = AGENT_CARD.model_dump()
-        mock_httpx_client.get.return_value = mock_response
-
-        resolver = A2ACardResolver(
-            httpx_client=mock_httpx_client,
-            base_url=self.BASE_URL,
-            agent_card_path=self.AGENT_CARD_PATH,
-        )
-        agent_card = await resolver.get_agent_card(http_kwargs={'timeout': 10})
-
-        mock_httpx_client.get.assert_called_once_with(
-            self.FULL_AGENT_CARD_URL, timeout=10
-        )
-        mock_response.raise_for_status.assert_called_once()
-        assert isinstance(agent_card, AgentCard)
-        assert agent_card == AGENT_CARD
-
-    @pytest.mark.asyncio
-    async def test_get_agent_card_http_status_error(
-        self, mock_httpx_client: AsyncMock
-    ):
-        mock_response = MagicMock(
-            spec=httpx.Response
-        )  # Use MagicMock for response attribute
-        mock_response.status_code = 404
-        mock_response.text = 'Not Found'
-
-        http_status_error = httpx.HTTPStatusError(
-            'Not Found', request=MagicMock(), response=mock_response
-        )
-        mock_httpx_client.get.side_effect = http_status_error
-
-        resolver = A2ACardResolver(
-            httpx_client=mock_httpx_client,
-            base_url=self.BASE_URL,
-            agent_card_path=self.AGENT_CARD_PATH,
-        )
-
-        with pytest.raises(A2AClientHTTPError) as exc_info:
-            await resolver.get_agent_card()
-
-        assert exc_info.value.status_code == 404
-        assert 'HTTP Error 404: Not Found' in str(exc_info.value)
-        mock_httpx_client.get.assert_called_once_with(self.FULL_AGENT_CARD_URL)
-
-    @pytest.mark.asyncio
-    async def test_get_agent_card_json_decode_error(
-        self, mock_httpx_client: AsyncMock
-    ):
-        mock_response = AsyncMock(spec=httpx.Response)
-        mock_response.status_code = 200
-        json_error = json.JSONDecodeError('Expecting value', 'doc', 0)
-        mock_response.json.side_effect = json_error
-        mock_httpx_client.get.return_value = mock_response
-
-        resolver = A2ACardResolver(
-            httpx_client=mock_httpx_client,
-            base_url=self.BASE_URL,
-            agent_card_path=self.AGENT_CARD_PATH,
-        )
-
-        with pytest.raises(A2AClientJSONError) as exc_info:
-            await resolver.get_agent_card()
-
-        assert 'JSON Error: Expecting value' in str(exc_info.value)
-        mock_httpx_client.get.assert_called_once_with(self.FULL_AGENT_CARD_URL)
-
-    @pytest.mark.asyncio
-    async def test_get_agent_card_request_error(
-        self, mock_httpx_client: AsyncMock
-    ):
-        request_error = httpx.RequestError('Network issue', request=MagicMock())
-        mock_httpx_client.get.side_effect = request_error
-
-        resolver = A2ACardResolver(
-            httpx_client=mock_httpx_client,
-            base_url=self.BASE_URL,
-            agent_card_path=self.AGENT_CARD_PATH,
-        )
-
-        with pytest.raises(A2AClientHTTPError) as exc_info:
-            await resolver.get_agent_card()
-
-        assert exc_info.value.status_code == 503
-        assert 'Network communication error: Network issue' in str(
-            exc_info.value
-        )
-        mock_httpx_client.get.assert_called_once_with(self.FULL_AGENT_CARD_URL)
-
-
-class TestA2AClient:
-    AGENT_URL = 'http://agent.example.com/api'
-
-    def test_init_with_agent_card(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        assert client.url == mock_agent_card.url
-        assert client.httpx_client == mock_httpx_client
-
-    def test_init_with_url(self, mock_httpx_client: AsyncMock):
-        client = A2AClient(httpx_client=mock_httpx_client, url=self.AGENT_URL)
-        assert client.url == self.AGENT_URL
-        assert client.httpx_client == mock_httpx_client
-
-    def test_init_with_agent_card_and_url_prioritizes_agent_card(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client,
-            agent_card=mock_agent_card,
-            url='http://otherurl.com',
-        )
-        assert (
-            client.url == mock_agent_card.url
-        )  # Agent card URL should be used
-
-    def test_init_raises_value_error_if_no_card_or_url(
-        self, mock_httpx_client: AsyncMock
-    ):
-        with pytest.raises(ValueError) as exc_info:
-            A2AClient(httpx_client=mock_httpx_client)
-        assert 'Must provide either agent_card or url' in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_get_client_from_agent_card_url_success(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        base_url = 'http://example.com'
-        agent_card_path = '/.well-known/custom-agent.json'
-        resolver_kwargs = {'timeout': 30}
-
-        mock_resolver_instance = AsyncMock(spec=A2ACardResolver)
-        mock_resolver_instance.get_agent_card.return_value = mock_agent_card
-
-        with patch(
-            'a2a.client.client.A2ACardResolver',
-            return_value=mock_resolver_instance,
-        ) as mock_resolver_class:
-            client = await A2AClient.get_client_from_agent_card_url(
-                httpx_client=mock_httpx_client,
-                base_url=base_url,
-                agent_card_path=agent_card_path,
-                http_kwargs=resolver_kwargs,
-            )
-
-            mock_resolver_class.assert_called_once_with(
-                mock_httpx_client,
-                base_url=base_url,
-                agent_card_path=agent_card_path,
-            )
-            mock_resolver_instance.get_agent_card.assert_called_once_with(
-                http_kwargs=resolver_kwargs
-            )
-            assert isinstance(client, A2AClient)
-            assert client.url == mock_agent_card.url
-            assert client.httpx_client == mock_httpx_client
-
-    @pytest.mark.asyncio
-    async def test_get_client_from_agent_card_url_resolver_error(
-        self, mock_httpx_client: AsyncMock
-    ):
-        error_to_raise = A2AClientHTTPError(404, 'Agent card not found')
-        with patch(
-            'a2a.client.client.A2ACardResolver.get_agent_card',
-            new_callable=AsyncMock,
-            side_effect=error_to_raise,
-        ):
-            with pytest.raises(A2AClientHTTPError) as exc_info:
-                await A2AClient.get_client_from_agent_card_url(
-                    httpx_client=mock_httpx_client,
-                    base_url='http://example.com',
-                )
-            assert exc_info.value == error_to_raise
-
-    @pytest.mark.asyncio
-    async def test_send_message_success_use_request(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-
-        params = MessageSendParams(
-            message=create_text_message_object(content='Hello')
-        )
-
-        request = SendMessageRequest(id=123, params=params)
-
-        success_response = create_text_message_object(
-            role=Role.agent, content='Hi there!'
-        ).model_dump(exclude_none=True)
-
-        rpc_response: dict[str, Any] = {
-            'id': 123,
-            'jsonrpc': '2.0',
-            'result': success_response,
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response
-            response = await client.send_message(
-                request=request, http_kwargs={'timeout': 10}
-            )
-
-            assert mock_send_req.call_count == 1
-            called_args, called_kwargs = mock_send_req.call_args
-            assert not called_kwargs  # no kwargs to _send_request
-            assert len(called_args) == 2
-            json_rpc_request: dict[str, Any] = called_args[0]
-            assert isinstance(json_rpc_request['id'], int)
-            http_kwargs: dict[str, Any] = called_args[1]
-            assert http_kwargs['timeout'] == 10
-
-            a2a_request_arg = A2ARequest.model_validate(json_rpc_request)
-            assert isinstance(a2a_request_arg.root, SendMessageRequest)
-            assert isinstance(a2a_request_arg.root.params, MessageSendParams)
-
-            assert a2a_request_arg.root.params.model_dump(
-                exclude_none=True
-            ) == params.model_dump(exclude_none=True)
-
-            assert isinstance(response, SendMessageResponse)
-            assert isinstance(response.root, SendMessageSuccessResponse)
-            assert (
-                response.root.result.model_dump(exclude_none=True)
-                == success_response
-            )
-
-    @pytest.mark.asyncio
-    async def test_send_message_error_response(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-
-        params = MessageSendParams(
-            message=create_text_message_object(content='Hello')
-        )
-
-        request = SendMessageRequest(id=123, params=params)
-
-        error_response = InvalidParamsError()
-
-        rpc_response: dict[str, Any] = {
-            'id': 123,
-            'jsonrpc': '2.0',
-            'error': error_response.model_dump(exclude_none=True),
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response
-            response = await client.send_message(request=request)
-
-            assert isinstance(response, SendMessageResponse)
-            assert isinstance(response.root, JSONRPCErrorResponse)
-            assert response.root.error.model_dump(
-                exclude_none=True
-            ) == InvalidParamsError().model_dump(exclude_none=True)
-
-    @pytest.mark.asyncio
-    @patch('a2a.client.client.aconnect_sse')
-    async def test_send_message_streaming_success_request(
-        self,
-        mock_aconnect_sse: AsyncMock,
-        mock_httpx_client: AsyncMock,
-        mock_agent_card: MagicMock,
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        params = MessageSendParams(
-            message=create_text_message_object(content='Hello stream')
-        )
-
-        request = SendStreamingMessageRequest(id=123, params=params)
-
-        mock_stream_response_1_dict: dict[str, Any] = {
-            'id': 'stream_id_123',
-            'jsonrpc': '2.0',
-            'result': create_text_message_object(
-                content='First part ', role=Role.agent
-            ).model_dump(mode='json', exclude_none=True),
-        }
-        mock_stream_response_2_dict: dict[str, Any] = {
-            'id': 'stream_id_123',
-            'jsonrpc': '2.0',
-            'result': create_text_message_object(
-                content='second part ', role=Role.agent
-            ).model_dump(mode='json', exclude_none=True),
-        }
-
-        sse_event_1 = ServerSentEvent(
-            data=json.dumps(mock_stream_response_1_dict)
-        )
-        sse_event_2 = ServerSentEvent(
-            data=json.dumps(mock_stream_response_2_dict)
-        )
-
-        mock_event_source = AsyncMock(spec=EventSource)
-        with patch.object(mock_event_source, 'aiter_sse') as mock_aiter_sse:
-            mock_aiter_sse.return_value = async_iterable_from_list(
-                [sse_event_1, sse_event_2]
-            )
-            mock_aconnect_sse.return_value.__aenter__.return_value = (
-                mock_event_source
-            )
-
-            results: list[Any] = []
-            async for response in client.send_message_streaming(
-                request=request
-            ):
-                results.append(response)
-
-            assert len(results) == 2
-            assert isinstance(results[0], SendStreamingMessageResponse)
-            # Assuming SendStreamingMessageResponse is a RootModel like SendMessageResponse
-            assert results[0].root.id == 'stream_id_123'
-            assert (
-                results[0].root.result.model_dump(  # type: ignore
-                    mode='json', exclude_none=True
-                )
-                == mock_stream_response_1_dict['result']
-            )
-
-            assert isinstance(results[1], SendStreamingMessageResponse)
-            assert results[1].root.id == 'stream_id_123'
-            assert (
-                results[1].root.result.model_dump(  # type: ignore
-                    mode='json', exclude_none=True
-                )
-                == mock_stream_response_2_dict['result']
-            )
-
-            mock_aconnect_sse.assert_called_once()
-            call_args, call_kwargs = mock_aconnect_sse.call_args
-            assert call_args[0] == mock_httpx_client
-            assert call_args[1] == 'POST'
-            assert call_args[2] == mock_agent_card.url
-
-            sent_json_payload = call_kwargs['json']
-            assert sent_json_payload['method'] == 'message/stream'
-            assert sent_json_payload['params'] == params.model_dump(
-                mode='json', exclude_none=True
-            )
-            assert (
-                call_kwargs['timeout'] is None
-            )  # Default timeout for streaming
-
-    @pytest.mark.asyncio
-    async def test_get_task_success_use_request(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        task_id_val = 'task_for_req_obj'
-        params_model = TaskQueryParams(id=task_id_val)
-        request_obj_id = 789
-        request = GetTaskRequest(id=request_obj_id, params=params_model)
-
-        rpc_response_payload: dict[str, Any] = {
-            'id': request_obj_id,
-            'jsonrpc': '2.0',
-            'result': MINIMAL_TASK,
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response_payload
-            response = await client.get_task(
-                request=request, http_kwargs={'timeout': 20}
-            )
-
-            assert mock_send_req.call_count == 1
-            called_args, called_kwargs = mock_send_req.call_args
-            assert len(called_args) == 2
-            json_rpc_request_sent: dict[str, Any] = called_args[0]
-            assert not called_kwargs  # no extra kwargs to _send_request
-            http_kwargs: dict[str, Any] = called_args[1]
-            assert http_kwargs['timeout'] == 20
-
-            assert json_rpc_request_sent['method'] == 'tasks/get'
-            assert json_rpc_request_sent['id'] == request_obj_id
-            assert json_rpc_request_sent['params'] == params_model.model_dump(
-                mode='json', exclude_none=True
-            )
-
-            assert isinstance(response, GetTaskResponse)
-            assert hasattr(response.root, 'result')
-            assert (
-                response.root.result.model_dump(mode='json', exclude_none=True)  # type: ignore
-                == MINIMAL_TASK
-            )
-            assert response.root.id == request_obj_id
-
-    @pytest.mark.asyncio
-    async def test_get_task_error_response(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        params_model = TaskQueryParams(id='task_error_case')
-        request = GetTaskRequest(id='err_req_id', params=params_model)
-        error_details = InvalidParamsError()
-
-        rpc_response_payload: dict[str, Any] = {
-            'id': 'err_req_id',
-            'jsonrpc': '2.0',
-            'error': error_details.model_dump(mode='json', exclude_none=True),
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response_payload
-            response = await client.get_task(request=request)
-
-            assert isinstance(response, GetTaskResponse)
-            assert isinstance(response.root, JSONRPCErrorResponse)
-            assert response.root.error.model_dump(
-                mode='json', exclude_none=True
-            ) == error_details.model_dump(exclude_none=True)
-            assert response.root.id == 'err_req_id'
-
-    @pytest.mark.asyncio
-    async def test_cancel_task_success_use_request(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        task_id_val = MINIMAL_CANCELLED_TASK['id']
-        params_model = TaskIdParams(id=task_id_val)
-        request_obj_id = 'cancel_req_obj_id_001'
-        request = CancelTaskRequest(id=request_obj_id, params=params_model)
-
-        rpc_response_payload: dict[str, Any] = {
-            'id': request_obj_id,
-            'jsonrpc': '2.0',
-            'result': MINIMAL_CANCELLED_TASK,
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response_payload
-            response = await client.cancel_task(
-                request=request, http_kwargs={'timeout': 15}
-            )
-
-            assert mock_send_req.call_count == 1
-            called_args, called_kwargs = mock_send_req.call_args
-            assert not called_kwargs  # no extra kwargs to _send_request
-            assert len(called_args) == 2
-            json_rpc_request_sent: dict[str, Any] = called_args[0]
-            http_kwargs: dict[str, Any] = called_args[1]
-            assert http_kwargs['timeout'] == 15
-
-            assert json_rpc_request_sent['method'] == 'tasks/cancel'
-            assert json_rpc_request_sent['id'] == request_obj_id
-            assert json_rpc_request_sent['params'] == params_model.model_dump(
-                mode='json', exclude_none=True
-            )
-
-            assert isinstance(response, CancelTaskResponse)
-            assert isinstance(response.root, CancelTaskSuccessResponse)
-            assert (
-                response.root.result.model_dump(mode='json', exclude_none=True)  # type: ignore
-                == MINIMAL_CANCELLED_TASK
-            )
-            assert response.root.id == request_obj_id
-
-    @pytest.mark.asyncio
-    async def test_cancel_task_error_response(
-        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
-    ):
-        client = A2AClient(
-            httpx_client=mock_httpx_client, agent_card=mock_agent_card
-        )
-        params_model = TaskIdParams(id='task_cancel_error_case')
-        request = CancelTaskRequest(id='err_cancel_req', params=params_model)
-        error_details = TaskNotCancelableError()
-
-        rpc_response_payload: dict[str, Any] = {
-            'id': 'err_cancel_req',
-            'jsonrpc': '2.0',
-            'error': error_details.model_dump(mode='json', exclude_none=True),
-        }
-
-        with patch.object(
-            client, '_send_request', new_callable=AsyncMock
-        ) as mock_send_req:
-            mock_send_req.return_value = rpc_response_payload
-            response = await client.cancel_task(request=request)
-
-            assert isinstance(response, CancelTaskResponse)
-            assert isinstance(response.root, JSONRPCErrorResponse)
-            assert response.root.error.model_dump(
-                mode='json', exclude_none=True
-            ) == error_details.model_dump(exclude_none=True)
-            assert response.root.id == 'err_cancel_req'
diff --git a/tests/client/test_client_factory.py b/tests/client/test_client_factory.py
new file mode 100644
index 000000000..10380d6c9
--- /dev/null
+++ b/tests/client/test_client_factory.py
@@ -0,0 +1,460 @@
+"""Tests for the ClientFactory."""
+
+import typing
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from a2a.client import ClientConfig, ClientFactory, create_client
+from a2a.client.client_factory import TransportProducer
+from a2a.client.errors import A2AClientError
+from a2a.client.transports import (
+    JsonRpcTransport,
+    RestTransport,
+)
+from a2a.client.transports.tenant_decorator import TenantTransportDecorator
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+)
+from a2a.utils.constants import (
+    TransportProtocol,
+)
+
+
+@pytest.fixture
+def base_agent_card() -> AgentCard:
+    """Provides a base AgentCard for tests."""
+    return AgentCard(
+        name='Test Agent',
+        description='An agent for testing.',
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://primary-url.com',
+            )
+        ],
+        version='1.0.0',
+        capabilities=AgentCapabilities(),
+        skills=[],
+        default_input_modes=[],
+        default_output_modes=[],
+    )
+
+
+def test_client_factory_selects_preferred_transport(base_agent_card: AgentCard):
+    """Verify that the factory selects the preferred transport by default."""
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=[
+            TransportProtocol.JSONRPC,
+            TransportProtocol.HTTP_JSON,
+        ],
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+def test_client_factory_selects_secondary_transport_url(
+    base_agent_card: AgentCard,
+):
+    """Verify that the factory selects the correct URL for a secondary transport."""
+    base_agent_card.supported_interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.HTTP_JSON,
+            url='http://secondary-url.com',
+        )
+    )
+    # Client prefers REST, which is available as a secondary transport
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=[
+            TransportProtocol.HTTP_JSON,
+            TransportProtocol.JSONRPC,
+        ],
+        use_client_preference=True,
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, RestTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://secondary-url.com'  # type: ignore[attr-defined]
+
+
+def test_client_factory_server_preference(base_agent_card: AgentCard):
+    """Verify that the factory respects server transport preference."""
+    # Server lists REST first, which implies preference
+    base_agent_card.supported_interfaces.insert(
+        0,
+        AgentInterface(
+            protocol_binding=TransportProtocol.HTTP_JSON,
+            url='http://primary-url.com',
+        ),
+    )
+    base_agent_card.supported_interfaces.append(
+        AgentInterface(
+            protocol_binding=TransportProtocol.JSONRPC,
+            url='http://secondary-url.com',
+        )
+    )
+    # Client supports both, but server prefers REST
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=[
+            TransportProtocol.JSONRPC,
+            TransportProtocol.HTTP_JSON,
+        ],
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, RestTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+@pytest.mark.parametrize('v1_version', ['1.0', '1.0.0'])
+def test_client_factory_prefers_1_0_ignoring_patch_version(
+    base_agent_card: AgentCard, v1_version: str
+):
+    """A patch version must not affect protocol negotiation (spec: Versioning)."""
+    del base_agent_card.supported_interfaces[:]
+    base_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://legacy-url.com',
+                protocol_version='0.3.0',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://v1-url.com',
+                protocol_version=v1_version,
+            ),
+        ]
+    )
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=[TransportProtocol.JSONRPC],
+    )
+    client = ClientFactory(config).create(base_agent_card)
+
+    assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://v1-url.com'  # type: ignore[attr-defined]
+
+
+def test_client_factory_no_compatible_transport(base_agent_card: AgentCard):
+    """Verify that the factory raises an error if no compatible transport is found."""
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=['UNKNOWN_PROTOCOL'],
+    )
+    factory = ClientFactory(config)
+    with pytest.raises(ValueError, match='no compatible transports found'):
+        factory.create(base_agent_card)
+
+
+def test_client_factory_create_with_default_config(
+    base_agent_card: AgentCard,
+):
+    """Verify that create works correctly with a default ClientConfig."""
+    factory = ClientFactory()
+    client = factory.create(base_agent_card)
+    assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_client_factory_create_from_url(base_agent_card: AgentCard):
+    """Verify that create_from_url resolves the card and creates a client."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        agent_url = 'http://example.com'
+        factory = ClientFactory()
+        client = await factory.create_from_url(agent_url)
+
+        mock_resolver.assert_called_once()
+        assert mock_resolver.call_args[0][1] == agent_url
+        mock_resolver.return_value.get_agent_card.assert_awaited_once()
+
+        assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+        assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_client_factory_create_from_url_uses_factory_httpx_client(
+    base_agent_card: AgentCard,
+):
+    """Verify create_from_url uses the factory's configured httpx client."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        agent_url = 'http://example.com'
+        mock_httpx_client = httpx.AsyncClient()
+        config = ClientConfig(httpx_client=mock_httpx_client)
+
+        factory = ClientFactory(config)
+        client = await factory.create_from_url(agent_url)
+
+        mock_resolver.assert_called_once_with(mock_httpx_client, agent_url)
+        mock_resolver.return_value.get_agent_card.assert_awaited_once()
+
+        assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+        assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_client_factory_create_from_url_passes_resolver_args(
+    base_agent_card: AgentCard,
+):
+    """Verify create_from_url passes resolver arguments correctly."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        agent_url = 'http://example.com'
+        relative_path = '/extendedAgentCard'
+        http_kwargs = {'headers': {'X-Test': 'true'}}
+
+        config = ClientConfig(httpx_client=httpx.AsyncClient())
+        factory = ClientFactory(config)
+
+        await factory.create_from_url(
+            agent_url,
+            relative_card_path=relative_path,
+            resolver_http_kwargs=http_kwargs,
+        )
+
+        mock_resolver.return_value.get_agent_card.assert_awaited_once_with(
+            relative_card_path=relative_path,
+            http_kwargs=http_kwargs,
+            signature_verifier=None,
+        )
+
+
+@pytest.mark.asyncio
+async def test_client_factory_create_from_url_with_default_config(
+    base_agent_card: AgentCard,
+):
+    """Verify create_from_url works with a default ClientConfig."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        agent_url = 'http://example.com'
+        relative_path = '/extendedAgentCard'
+        http_kwargs = {'headers': {'X-Test': 'true'}}
+
+        factory = ClientFactory()
+
+        await factory.create_from_url(
+            agent_url,
+            relative_card_path=relative_path,
+            resolver_http_kwargs=http_kwargs,
+        )
+
+        # Factory always creates an httpx client, so resolver gets it
+        mock_resolver.assert_called_once()
+        mock_resolver.return_value.get_agent_card.assert_awaited_once_with(
+            relative_card_path=relative_path,
+            http_kwargs=http_kwargs,
+            signature_verifier=None,
+        )
+
+
+def test_client_factory_register_and_create_custom_transport(
+    base_agent_card: AgentCard,
+):
+    """Verify that register() + create() uses custom transports."""
+
+    class CustomTransport:
+        pass
+
+    def custom_transport_producer(
+        *args: typing.Any, **kwargs: typing.Any
+    ) -> CustomTransport:
+        return CustomTransport()
+
+    base_agent_card.supported_interfaces.insert(
+        0,
+        AgentInterface(protocol_binding='custom', url='custom://foo'),
+    )
+
+    config = ClientConfig(supported_protocol_bindings=['custom'])
+    factory = ClientFactory(config)
+    factory.register(
+        'custom',
+        typing.cast(TransportProducer, custom_transport_producer),
+    )
+
+    client = factory.create(base_agent_card)
+    assert isinstance(client._transport, CustomTransport)  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_client_factory_create_from_url_uses_registered_transports(
+    base_agent_card: AgentCard,
+):
+    """Verify that create_from_url() respects custom transports from register()."""
+
+    class CustomTransport:
+        pass
+
+    def custom_transport_producer(
+        *args: typing.Any, **kwargs: typing.Any
+    ) -> CustomTransport:
+        return CustomTransport()
+
+    base_agent_card.supported_interfaces.insert(
+        0,
+        AgentInterface(protocol_binding='custom', url='custom://foo'),
+    )
+
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        config = ClientConfig(supported_protocol_bindings=['custom'])
+        factory = ClientFactory(config)
+        factory.register(
+            'custom',
+            typing.cast(TransportProducer, custom_transport_producer),
+        )
+
+        client = await factory.create_from_url('http://example.com')
+        assert isinstance(client._transport, CustomTransport)  # type: ignore[attr-defined]
+
+
+def test_client_factory_create_with_interceptors(
+    base_agent_card: AgentCard,
+):
+    """Verify interceptors are passed through correctly."""
+    interceptor1 = MagicMock()
+
+    with patch('a2a.client.client_factory.BaseClient') as mock_base_client:
+        factory = ClientFactory()
+        factory.create(
+            base_agent_card,
+            interceptors=[interceptor1],
+        )
+
+        mock_base_client.assert_called_once()
+        call_args = mock_base_client.call_args[0]
+        assert call_args[3] == [interceptor1]
+
+
+def test_client_factory_applies_tenant_decorator(base_agent_card: AgentCard):
+    """Verify that the factory applies TenantTransportDecorator when tenant is present."""
+    base_agent_card.supported_interfaces[0].tenant = 'my-tenant'
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_protocol_bindings=[TransportProtocol.JSONRPC],
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, TenantTransportDecorator)  # type: ignore[attr-defined]
+    assert client._transport._tenant == 'my-tenant'  # type: ignore[attr-defined]
+    assert isinstance(client._transport._base, JsonRpcTransport)  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_create_client_with_agent_card(base_agent_card: AgentCard):
+    """Verify create_client works when given an AgentCard directly."""
+    client = await create_client(base_agent_card)
+    assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+    assert client._transport.url == 'http://primary-url.com'  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_create_client_with_url(base_agent_card: AgentCard):
+    """Verify create_client resolves a URL and creates a client."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        client = await create_client('http://example.com')
+
+        mock_resolver.assert_called_once()
+        assert mock_resolver.call_args[0][1] == 'http://example.com'
+        assert isinstance(client._transport, JsonRpcTransport)  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_create_client_with_url_and_config(base_agent_card: AgentCard):
+    """Verify create_client passes client_config to the factory."""
+    with patch('a2a.client.client_factory.A2ACardResolver') as mock_resolver:
+        mock_resolver.return_value.get_agent_card = AsyncMock(
+            return_value=base_agent_card
+        )
+
+        mock_httpx_client = httpx.AsyncClient()
+        config = ClientConfig(httpx_client=mock_httpx_client)
+
+        await create_client('http://example.com', client_config=config)
+
+        mock_resolver.assert_called_once_with(
+            mock_httpx_client, 'http://example.com'
+        )
+
+
+@pytest.mark.asyncio
+async def test_client_factory_creates_a_client_per_created_client(
+    base_agent_card: AgentCard,
+):
+    """Verify each created client gets its own httpx client by default."""
+    factory = ClientFactory()
+
+    client_a = factory.create(base_agent_card)
+    client_b = factory.create(base_agent_card)
+
+    assert (
+        client_a._transport.httpx_client  # type: ignore[attr-defined]
+        is not client_b._transport.httpx_client  # type: ignore[attr-defined]
+    )
+
+
+@pytest.mark.asyncio
+async def test_client_close_does_not_close_shared_httpx_client(
+    base_agent_card: AgentCard,
+):
+    """Verify closing a client does not close a shared httpx_client from config."""
+    shared_httpx_client = httpx.AsyncClient()
+    try:
+        factory = ClientFactory(ClientConfig(httpx_client=shared_httpx_client))
+        client = factory.create(base_agent_card)
+
+        await client.close()
+
+        assert not shared_httpx_client.is_closed
+    finally:
+        await shared_httpx_client.aclose()
+
+
+@pytest.mark.asyncio
+async def test_client_second_close_raises_a2a_client_error(
+    base_agent_card: AgentCard,
+):
+    """Verify closing an already closed client raises A2AClientError."""
+    factory = ClientFactory()
+    client = factory.create(base_agent_card)
+
+    await client.close()
+    assert client._transport.httpx_client.is_closed  # type: ignore[attr-defined]
+
+    with pytest.raises(A2AClientError, match='HTTP client is already closed'):
+        await client.close()
diff --git a/tests/client/test_client_factory_grpc.py b/tests/client/test_client_factory_grpc.py
new file mode 100644
index 000000000..7c3b68b29
--- /dev/null
+++ b/tests/client/test_client_factory_grpc.py
@@ -0,0 +1,176 @@
+"""Tests for GRPC transport selection in ClientFactory."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from a2a.client import ClientConfig, ClientFactory
+from a2a.types.a2a_pb2 import AgentCapabilities, AgentCard, AgentInterface
+from a2a.utils.constants import TransportProtocol
+
+
+@pytest.fixture
+def grpc_agent_card() -> AgentCard:
+    """Provides an AgentCard with GRPC interfaces for tests."""
+    return AgentCard(
+        supported_interfaces=[],
+        capabilities=AgentCapabilities(),
+        skills=[],
+        default_input_modes=[],
+        default_output_modes=[],
+        name='GRPC Agent',
+        version='1.0.0',
+        description='Test agent',
+    )
+
+
+def test_grpc_priority_1_0(grpc_agent_card):
+    """Verify that protocol version 1.0 has the highest priority and uses GrpcTransport."""
+    grpc_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url03',
+                protocol_version='0.3',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url11',
+                protocol_version='1.1',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url10',
+                protocol_version='1.0',
+            ),
+        ]
+    )
+
+    config = ClientConfig(
+        supported_protocol_bindings=[TransportProtocol.GRPC],
+        grpc_channel_factory=MagicMock(),
+    )
+
+    # We patch GrpcTransport and CompatGrpcTransport in the client_factory module
+    with (
+        patch('a2a.client.client_factory.GrpcTransport') as mock_grpc,
+        patch('a2a.client.client_factory.CompatGrpcTransport') as mock_compat,
+    ):
+        factory = ClientFactory(config)
+        factory.create(grpc_agent_card)
+
+        # Priority 1: 1.0 -> GrpcTransport
+        mock_grpc.create.assert_called_once_with(
+            grpc_agent_card, 'url10', config
+        )
+        mock_compat.create.assert_not_called()
+
+
+def test_grpc_priority_gt_1_0(grpc_agent_card):
+    """Verify that protocol version > 1.0 uses GrpcTransport (first one found)."""
+    grpc_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url03',
+                protocol_version='0.3',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url11',
+                protocol_version='1.1',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url12',
+                protocol_version='1.2',
+            ),
+        ]
+    )
+
+    config = ClientConfig(
+        supported_protocol_bindings=[TransportProtocol.GRPC],
+        grpc_channel_factory=MagicMock(),
+    )
+
+    with (
+        patch('a2a.client.client_factory.GrpcTransport') as mock_grpc,
+        patch('a2a.client.client_factory.CompatGrpcTransport') as mock_compat,
+    ):
+        factory = ClientFactory(config)
+        factory.create(grpc_agent_card)
+
+        # Priority 2: > 1.0 -> GrpcTransport (first matching is 1.1)
+        mock_grpc.create.assert_called_once_with(
+            grpc_agent_card, 'url11', config
+        )
+        mock_compat.create.assert_not_called()
+
+
+def test_grpc_priority_lt_0_3_raises_value_error(grpc_agent_card):
+    """Verify that if the only available interface has version < 0.3, it raises a ValueError."""
+    grpc_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url02',
+                protocol_version='0.2',
+            ),
+        ]
+    )
+
+    config = ClientConfig(
+        supported_protocol_bindings=[TransportProtocol.GRPC],
+        grpc_channel_factory=MagicMock(),
+    )
+
+    factory = ClientFactory(config)
+    with pytest.raises(ValueError, match='no compatible transports found'):
+        factory.create(grpc_agent_card)
+
+
+def test_grpc_invalid_version_raises_value_error(grpc_agent_card):
+    """Verify that if only an invalid version is available, it raises a ValueError (it's ignored)."""
+    grpc_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url_invalid',
+                protocol_version='invalid_version_string',
+            ),
+        ]
+    )
+
+    config = ClientConfig(
+        supported_protocol_bindings=[TransportProtocol.GRPC],
+        grpc_channel_factory=MagicMock(),
+    )
+
+    factory = ClientFactory(config)
+    with pytest.raises(ValueError, match='no compatible transports found'):
+        factory.create(grpc_agent_card)
+
+
+def test_grpc_unspecified_version_uses_grpc_transport(grpc_agent_card):
+    """Verify that if no version is specified, it defaults to GrpcTransport."""
+    grpc_agent_card.supported_interfaces.extend(
+        [
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='url_no_version',
+            ),
+        ]
+    )
+
+    config = ClientConfig(
+        supported_protocol_bindings=[TransportProtocol.GRPC],
+        grpc_channel_factory=MagicMock(),
+    )
+
+    with patch('a2a.client.client_factory.GrpcTransport') as mock_grpc:
+        factory = ClientFactory(config)
+        factory.create(grpc_agent_card)
+
+        mock_grpc.create.assert_called_once_with(
+            grpc_agent_card, 'url_no_version', config
+        )
diff --git a/tests/client/test_errors.py b/tests/client/test_errors.py
new file mode 100644
index 000000000..280f1c293
--- /dev/null
+++ b/tests/client/test_errors.py
@@ -0,0 +1,60 @@
+import pytest
+
+from a2a.client import (
+    A2AClientError,
+    A2AClientTimeoutError,
+    AgentCardResolutionError,
+)
+
+
+class TestA2AClientError:
+    """Test cases for the base A2AClientError class."""
+
+    def test_instantiation(self) -> None:
+        """Test that A2AClientError can be instantiated."""
+        error = A2AClientError('Test error message')
+        assert isinstance(error, Exception)
+        assert str(error) == 'Test error message'
+
+    def test_inheritance(self) -> None:
+        """Test that A2AClientError inherits from Exception."""
+        error = A2AClientError()
+        assert isinstance(error, Exception)
+
+    def test_raising_base_error(self) -> None:
+        """Test raising the base error."""
+        with pytest.raises(A2AClientError) as excinfo:
+            raise A2AClientError('Generic client error')
+
+        assert str(excinfo.value) == 'Generic client error'
+
+
+class TestClientErrorRepr:
+    """Test cases for the __repr__ of client exception classes."""
+
+    @pytest.mark.parametrize(
+        ('error', 'expected'),
+        [
+            (
+                A2AClientError('Network communication error'),
+                "A2AClientError(message='Network communication error', data=None)",
+            ),
+            (
+                A2AClientTimeoutError('Client Request timed out'),
+                "A2AClientTimeoutError(message='Client Request timed out', data=None)",
+            ),
+            (
+                AgentCardResolutionError('Failed to fetch agent card', 404),
+                'AgentCardResolutionError(status_code=404, '
+                "message='Failed to fetch agent card')",
+            ),
+            (
+                AgentCardResolutionError('Invalid agent card JSON'),
+                'AgentCardResolutionError(status_code=None, '
+                "message='Invalid agent card JSON')",
+            ),
+        ],
+    )
+    def test_repr(self, error: A2AClientError, expected: str) -> None:
+        """Test that repr exposes structured attributes as keyword arguments."""
+        assert repr(error) == expected
diff --git a/tests/client/test_optionals.py b/tests/client/test_optionals.py
new file mode 100644
index 000000000..81cbd387d
--- /dev/null
+++ b/tests/client/test_optionals.py
@@ -0,0 +1,16 @@
+"""Tests for a2a.client.optionals module."""
+
+import importlib
+import sys
+
+from unittest.mock import patch
+
+
+def test_channel_import_failure():
+    """Test Channel behavior when grpc is not available."""
+    with patch.dict('sys.modules', {'grpc': None, 'grpc.aio': None}):
+        if 'a2a.client.optionals' in sys.modules:
+            del sys.modules['a2a.client.optionals']
+
+        optionals = importlib.import_module('a2a.client.optionals')
+        assert optionals.Channel is None
diff --git a/tests/client/test_service_parameters.py b/tests/client/test_service_parameters.py
new file mode 100644
index 000000000..fbabd9719
--- /dev/null
+++ b/tests/client/test_service_parameters.py
@@ -0,0 +1,53 @@
+"""Tests for a2a.client.service_parameters module."""
+
+from a2a.client.service_parameters import (
+    ServiceParametersFactory,
+    with_a2a_extensions,
+)
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+
+
+def test_with_a2a_extensions_merges_dedupes_and_sorts():
+    """Repeated calls accumulate; duplicates collapse; output is sorted."""
+    parameters = ServiceParametersFactory.create(
+        [
+            with_a2a_extensions(['ext-c', 'ext-a']),
+            with_a2a_extensions(['ext-b', 'ext-a']),
+        ]
+    )
+
+    assert parameters[HTTP_EXTENSION_HEADER] == 'ext-a,ext-b,ext-c'
+
+
+def test_with_a2a_extensions_merges_existing_header_value():
+    """Pre-existing comma-separated header values are parsed and merged."""
+    parameters = ServiceParametersFactory.create_from(
+        {HTTP_EXTENSION_HEADER: 'ext-a, ext-b'},
+        [with_a2a_extensions(['ext-c'])],
+    )
+
+    assert parameters[HTTP_EXTENSION_HEADER] == 'ext-a,ext-b,ext-c'
+
+
+def test_with_a2a_extensions_empty_is_noop():
+    """An empty extensions list leaves the header untouched / absent."""
+    parameters = ServiceParametersFactory.create(
+        [
+            with_a2a_extensions(['ext-a']),
+            with_a2a_extensions([]),
+        ]
+    )
+
+    assert parameters[HTTP_EXTENSION_HEADER] == 'ext-a'
+    assert HTTP_EXTENSION_HEADER not in ServiceParametersFactory.create(
+        [with_a2a_extensions([])]
+    )
+
+
+def test_with_a2a_extensions_normalizes_input_strings():
+    """Input strings are split on commas and stripped, like header values."""
+    parameters = ServiceParametersFactory.create(
+        [with_a2a_extensions(['ext-a, ext-b', '  ext-c  '])]
+    )
+
+    assert parameters[HTTP_EXTENSION_HEADER] == 'ext-a,ext-b,ext-c'
diff --git a/tests/client/transports/__init__.py b/tests/client/transports/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/client/transports/test_grpc_client.py b/tests/client/transports/test_grpc_client.py
new file mode 100644
index 000000000..66306c0ec
--- /dev/null
+++ b/tests/client/transports/test_grpc_client.py
@@ -0,0 +1,683 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import grpc
+import pytest
+
+from a2a.client.client import ClientCallContext
+from a2a.client.transports.grpc import GrpcTransport
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.helpers.proto_helpers import get_text_parts
+from a2a.types import a2a_pb2
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Artifact,
+    AuthenticationInfo,
+    DeleteTaskPushNotificationConfigRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import PROTOCOL_VERSION_CURRENT, VERSION_HEADER
+from a2a.utils.errors import A2A_ERROR_REASONS
+from google.protobuf import any_pb2
+from google.rpc import error_details_pb2, status_pb2
+
+
+@pytest.fixture
+def mock_grpc_stub() -> AsyncMock:
+    """Provides a mock gRPC stub with methods mocked."""
+    stub = MagicMock()  # Use MagicMock without spec to avoid auto-spec warnings
+    stub.SendMessage = AsyncMock()
+    stub.SendStreamingMessage = MagicMock()
+    stub.GetTask = AsyncMock()
+    stub.ListTasks = AsyncMock()
+    stub.CancelTask = AsyncMock()
+    stub.CreateTaskPushNotificationConfig = AsyncMock()
+    stub.GetTaskPushNotificationConfig = AsyncMock()
+    stub.ListTaskPushNotificationConfigs = AsyncMock()
+    stub.DeleteTaskPushNotificationConfig = AsyncMock()
+    return stub
+
+
+@pytest.fixture
+def sample_agent_card() -> AgentCard:
+    """Provides a minimal agent card for initialization."""
+    return AgentCard(
+        name='gRPC Test Agent',
+        description='Agent for testing gRPC client',
+        supported_interfaces=[
+            AgentInterface(
+                url='grpc://localhost:50051', protocol_binding='GRPC'
+            )
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[],
+    )
+
+
+@pytest.fixture
+def grpc_transport(
+    mock_grpc_stub: AsyncMock, sample_agent_card: AgentCard
+) -> GrpcTransport:
+    """Provides a GrpcTransport instance."""
+    channel = MagicMock()  # Use MagicMock instead of AsyncMock
+    transport = GrpcTransport(
+        channel=channel,
+        agent_card=sample_agent_card,
+    )
+    transport.stub = mock_grpc_stub
+    return transport
+
+
+@pytest.fixture
+def sample_message_send_params() -> SendMessageRequest:
+    """Provides a sample SendMessageRequest object."""
+    return SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-1',
+            parts=[Part(text='Hello')],
+        )
+    )
+
+
+@pytest.fixture
+def sample_task() -> Task:
+    """Provides a sample Task object."""
+    return Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+    )
+
+
+@pytest.fixture
+def sample_task_2() -> Task:
+    """Provides a sample Task object."""
+    return Task(
+        id='task-2',
+        context_id='ctx-2',
+        status=TaskStatus(state=TaskState.TASK_STATE_FAILED),
+    )
+
+
+@pytest.fixture
+def sample_message() -> Message:
+    """Provides a sample Message object."""
+    return Message(
+        role=Role.ROLE_AGENT,
+        message_id='msg-response',
+        parts=[Part(text='Hi there')],
+    )
+
+
+@pytest.fixture
+def sample_artifact() -> Artifact:
+    """Provides a sample Artifact object."""
+    return Artifact(
+        artifact_id='artifact-1',
+        name='example.txt',
+        description='An example artifact',
+        parts=[Part(text='Hi there')],
+        metadata={},
+        extensions=[],
+    )
+
+
+@pytest.fixture
+def sample_task_status_update_event() -> TaskStatusUpdateEvent:
+    """Provides a sample TaskStatusUpdateEvent."""
+    return TaskStatusUpdateEvent(
+        task_id='task-1',
+        context_id='ctx-1',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        metadata={},
+    )
+
+
+@pytest.fixture
+def sample_task_artifact_update_event(
+    sample_artifact: Artifact,
+) -> TaskArtifactUpdateEvent:
+    """Provides a sample TaskArtifactUpdateEvent."""
+    return TaskArtifactUpdateEvent(
+        task_id='task-1',
+        context_id='ctx-1',
+        artifact=sample_artifact,
+        append=True,
+        last_chunk=True,
+        metadata={},
+    )
+
+
+@pytest.fixture
+def sample_authentication_info() -> AuthenticationInfo:
+    """Provides a sample AuthenticationInfo object."""
+    return AuthenticationInfo(scheme='apikey', credentials='secret-token')
+
+
+@pytest.fixture
+def sample_task_push_notification_config(
+    sample_authentication_info: AuthenticationInfo,
+) -> TaskPushNotificationConfig:
+    """Provides a sample TaskPushNotificationConfig object."""
+    return TaskPushNotificationConfig(
+        task_id='task-1',
+        id='config-1',
+        url='https://example.com/notify',
+        token='example-token',
+        authentication=sample_authentication_info,
+    )
+
+
+@pytest.mark.asyncio
+async def test_send_message_task_response(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_message_send_params: SendMessageRequest,
+    sample_task: Task,
+) -> None:
+    """Test send_message that returns a Task."""
+    mock_grpc_stub.SendMessage.return_value = a2a_pb2.SendMessageResponse(
+        task=sample_task
+    )
+
+    response = await grpc_transport.send_message(
+        sample_message_send_params,
+        context=ClientCallContext(
+            service_parameters={
+                HTTP_EXTENSION_HEADER: 'https://example.com/test-ext/v3'
+            }
+        ),
+    )
+
+    mock_grpc_stub.SendMessage.assert_awaited_once()
+    _, kwargs = mock_grpc_stub.SendMessage.call_args
+    assert kwargs['metadata'] == [
+        (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        (
+            HTTP_EXTENSION_HEADER.lower(),
+            'https://example.com/test-ext/v3',
+        ),
+    ]
+    assert response.HasField('task')
+    assert response.task.id == sample_task.id
+
+
+@pytest.mark.asyncio
+async def test_send_message_with_timeout_context(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_message_send_params: SendMessageRequest,
+    sample_task: Task,
+) -> None:
+    """Test send_message passes context timeout to grpc stub."""
+    from a2a.client.client import ClientCallContext
+
+    mock_grpc_stub.SendMessage.return_value = a2a_pb2.SendMessageResponse(
+        task=sample_task
+    )
+    context = ClientCallContext(timeout=12.5)
+
+    await grpc_transport.send_message(
+        sample_message_send_params,
+        context=context,
+    )
+
+    mock_grpc_stub.SendMessage.assert_awaited_once()
+    _, kwargs = mock_grpc_stub.SendMessage.call_args
+    assert 'timeout' in kwargs
+    assert kwargs['timeout'] == 12.5
+
+
+@pytest.mark.parametrize('error_cls', list(A2A_ERROR_REASONS.keys()))
+@pytest.mark.asyncio
+async def test_grpc_mapped_errors_rich(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_message_send_params: SendMessageRequest,
+    error_cls,
+) -> None:
+    """Test handling of rich gRPC error responses with Status metadata."""
+
+    reason = A2A_ERROR_REASONS.get(error_cls, 'UNKNOWN_ERROR')
+
+    error_info = error_details_pb2.ErrorInfo(
+        reason=reason,
+        domain='a2a-protocol.org',
+    )
+
+    error_details = f'{error_cls.__name__}: Mapped Error'
+    status = status_pb2.Status(
+        code=grpc.StatusCode.INTERNAL.value[0], message=error_details
+    )
+    detail = any_pb2.Any()
+    detail.Pack(error_info)
+    status.details.append(detail)
+
+    mock_grpc_stub.SendMessage.side_effect = grpc.aio.AioRpcError(
+        code=grpc.StatusCode.INTERNAL,
+        initial_metadata=grpc.aio.Metadata(),
+        trailing_metadata=grpc.aio.Metadata(
+            ('grpc-status-details-bin', status.SerializeToString()),
+        ),
+        details=error_details,
+    )
+
+    with pytest.raises(error_cls) as excinfo:
+        await grpc_transport.send_message(sample_message_send_params)
+
+    assert str(excinfo.value) == error_details
+
+
+@pytest.mark.asyncio
+async def test_send_message_message_response(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_message_send_params: SendMessageRequest,
+    sample_message: Message,
+) -> None:
+    """Test send_message that returns a Message."""
+    mock_grpc_stub.SendMessage.return_value = a2a_pb2.SendMessageResponse(
+        message=sample_message
+    )
+
+    response = await grpc_transport.send_message(sample_message_send_params)
+
+    mock_grpc_stub.SendMessage.assert_awaited_once()
+    _, kwargs = mock_grpc_stub.SendMessage.call_args
+    assert kwargs['metadata'] == [
+        (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+    ]
+    assert response.HasField('message')
+    assert response.message.message_id == sample_message.message_id
+    assert get_text_parts(response.message.parts) == get_text_parts(
+        sample_message.parts
+    )
+
+
+@pytest.mark.asyncio
+async def test_send_message_streaming(  # noqa: PLR0913
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_message_send_params: SendMessageRequest,
+    sample_message: Message,
+    sample_task: Task,
+    sample_task_status_update_event: TaskStatusUpdateEvent,
+    sample_task_artifact_update_event: TaskArtifactUpdateEvent,
+) -> None:
+    """Test send_message_streaming that yields responses."""
+    stream = MagicMock()
+    stream.read = AsyncMock(
+        side_effect=[
+            a2a_pb2.StreamResponse(message=sample_message),
+            a2a_pb2.StreamResponse(task=sample_task),
+            a2a_pb2.StreamResponse(
+                status_update=sample_task_status_update_event
+            ),
+            a2a_pb2.StreamResponse(
+                artifact_update=sample_task_artifact_update_event
+            ),
+            grpc.aio.EOF,  # type: ignore[attr-defined]
+        ]
+    )
+    mock_grpc_stub.SendStreamingMessage.return_value = stream
+
+    responses = [
+        response
+        async for response in grpc_transport.send_message_streaming(
+            sample_message_send_params
+        )
+    ]
+
+    mock_grpc_stub.SendStreamingMessage.assert_called_once()
+    _, kwargs = mock_grpc_stub.SendStreamingMessage.call_args
+    assert kwargs['metadata'] == [
+        (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+    ]
+    # Responses are StreamResponse proto objects
+    assert responses[0].HasField('message')
+    assert responses[0].message.message_id == sample_message.message_id
+    assert responses[1].HasField('task')
+    assert responses[1].task.id == sample_task.id
+    assert responses[2].HasField('status_update')
+    assert (
+        responses[2].status_update.task_id
+        == sample_task_status_update_event.task_id
+    )
+    assert responses[3].HasField('artifact_update')
+    assert (
+        responses[3].artifact_update.task_id
+        == sample_task_artifact_update_event.task_id
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_task(
+    grpc_transport: GrpcTransport, mock_grpc_stub: AsyncMock, sample_task: Task
+) -> None:
+    """Test retrieving a task."""
+    mock_grpc_stub.GetTask.return_value = sample_task
+    params = GetTaskRequest(id=f'{sample_task.id}')
+
+    response = await grpc_transport.get_task(params)
+
+    mock_grpc_stub.GetTask.assert_awaited_once_with(
+        a2a_pb2.GetTaskRequest(id=f'{sample_task.id}', history_length=None),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+    assert response.id == sample_task.id
+
+
+@pytest.mark.asyncio
+async def test_list_tasks(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task: Task,
+    sample_task_2: Task,
+):
+    """Test listing tasks."""
+    mock_grpc_stub.ListTasks.return_value = a2a_pb2.ListTasksResponse(
+        tasks=[sample_task, sample_task_2],
+        total_size=2,
+    )
+    params = a2a_pb2.ListTasksRequest()
+
+    result = await grpc_transport.list_tasks(params)
+
+    mock_grpc_stub.ListTasks.assert_awaited_once_with(
+        params,
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+    assert result.total_size == 2
+    assert not result.next_page_token
+    assert [t.id for t in result.tasks] == [sample_task.id, sample_task_2.id]
+
+
+@pytest.mark.asyncio
+async def test_get_task_with_history(
+    grpc_transport: GrpcTransport, mock_grpc_stub: AsyncMock, sample_task: Task
+) -> None:
+    """Test retrieving a task with history."""
+    mock_grpc_stub.GetTask.return_value = sample_task
+    history_len = 10
+    params = GetTaskRequest(id=f'{sample_task.id}', history_length=history_len)
+
+    await grpc_transport.get_task(params)
+
+    mock_grpc_stub.GetTask.assert_awaited_once_with(
+        a2a_pb2.GetTaskRequest(
+            id=f'{sample_task.id}', history_length=history_len
+        ),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_cancel_task(
+    grpc_transport: GrpcTransport, mock_grpc_stub: AsyncMock, sample_task: Task
+) -> None:
+    """Test cancelling a task."""
+    cancelled_task = Task(
+        id=sample_task.id,
+        context_id=sample_task.context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_CANCELED),
+    )
+    mock_grpc_stub.CancelTask.return_value = cancelled_task
+    extensions = 'https://example.com/test-ext/v3'
+
+    request = a2a_pb2.CancelTaskRequest(id=f'{sample_task.id}')
+    response = await grpc_transport.cancel_task(
+        request,
+        context=ClientCallContext(
+            service_parameters={HTTP_EXTENSION_HEADER: extensions}
+        ),
+    )
+
+    mock_grpc_stub.CancelTask.assert_awaited_once_with(
+        a2a_pb2.CancelTaskRequest(id=f'{sample_task.id}'),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+            (HTTP_EXTENSION_HEADER.lower(), 'https://example.com/test-ext/v3'),
+        ],
+        timeout=None,
+    )
+    assert response.status.state == TaskState.TASK_STATE_CANCELED
+
+
+@pytest.mark.asyncio
+async def test_create_task_push_notification_config_with_valid_task(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test setting a task push notification config with a valid task id."""
+    mock_grpc_stub.CreateTaskPushNotificationConfig.return_value = (
+        sample_task_push_notification_config
+    )
+
+    # Create the request object expected by the transport
+    request = TaskPushNotificationConfig(
+        task_id='task-1',
+        url='https://example.com/notify',
+    )
+    response = await grpc_transport.create_task_push_notification_config(
+        request
+    )
+
+    mock_grpc_stub.CreateTaskPushNotificationConfig.assert_awaited_once_with(
+        request,
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+    assert response.task_id == sample_task_push_notification_config.task_id
+
+
+@pytest.mark.asyncio
+async def test_create_task_push_notification_config_with_invalid_task(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test setting a task push notification config with an invalid task name format."""
+    # Return a config with an invalid name format
+    mock_grpc_stub.CreateTaskPushNotificationConfig.return_value = (
+        a2a_pb2.TaskPushNotificationConfig(
+            task_id='invalid-path-to-task-1',
+            id='config-1',
+            url='https://example.com/notify',
+        )
+    )
+
+    request = TaskPushNotificationConfig(
+        task_id='task-1',
+        id='config-1',
+        url='https://example.com/notify',
+    )
+
+    # Note: The transport doesn't validate the response name format
+    # It just returns the response from the stub
+    response = await grpc_transport.create_task_push_notification_config(
+        request
+    )
+    assert response.task_id == 'invalid-path-to-task-1'
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_with_valid_task(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test retrieving a task push notification config with a valid task id."""
+    mock_grpc_stub.GetTaskPushNotificationConfig.return_value = (
+        sample_task_push_notification_config
+    )
+    config_id = sample_task_push_notification_config.id
+
+    response = await grpc_transport.get_task_push_notification_config(
+        GetTaskPushNotificationConfigRequest(
+            task_id='task-1',
+            id=config_id,
+        )
+    )
+
+    mock_grpc_stub.GetTaskPushNotificationConfig.assert_awaited_once_with(
+        a2a_pb2.GetTaskPushNotificationConfigRequest(
+            task_id='task-1',
+            id=config_id,
+        ),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+    assert response.task_id == sample_task_push_notification_config.task_id
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_with_invalid_task(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test retrieving a task push notification config with an invalid task name."""
+    mock_grpc_stub.GetTaskPushNotificationConfig.return_value = (
+        a2a_pb2.TaskPushNotificationConfig(
+            task_id='invalid-path-to-task-1',
+            id='config-1',
+            url='https://example.com/notify',
+        )
+    )
+
+    response = await grpc_transport.get_task_push_notification_config(
+        GetTaskPushNotificationConfigRequest(
+            task_id='task-1',
+            id='config-1',
+        )
+    )
+    # The transport doesn't validate the response name format
+    assert response.task_id == 'invalid-path-to-task-1'
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_configs(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test retrieving task push notification configs."""
+    mock_grpc_stub.ListTaskPushNotificationConfigs.return_value = (
+        a2a_pb2.ListTaskPushNotificationConfigsResponse(
+            configs=[sample_task_push_notification_config]
+        )
+    )
+
+    response = await grpc_transport.list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task-1')
+    )
+
+    mock_grpc_stub.ListTaskPushNotificationConfigs.assert_awaited_once_with(
+        a2a_pb2.ListTaskPushNotificationConfigsRequest(task_id='task-1'),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+    assert len(response.configs) == 1
+    assert response.configs[0].task_id == 'task-1'
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config(
+    grpc_transport: GrpcTransport,
+    mock_grpc_stub: AsyncMock,
+    sample_task_push_notification_config: TaskPushNotificationConfig,
+) -> None:
+    """Test deleting task push notification config."""
+    mock_grpc_stub.DeleteTaskPushNotificationConfig.return_value = None
+
+    await grpc_transport.delete_task_push_notification_config(
+        DeleteTaskPushNotificationConfigRequest(
+            task_id='task-1',
+            id='config-1',
+        )
+    )
+
+    mock_grpc_stub.DeleteTaskPushNotificationConfig.assert_awaited_once_with(
+        a2a_pb2.DeleteTaskPushNotificationConfigRequest(
+            task_id='task-1',
+            id='config-1',
+        ),
+        metadata=[
+            (VERSION_HEADER.lower(), PROTOCOL_VERSION_CURRENT),
+        ],
+        timeout=None,
+    )
+
+
+@pytest.mark.parametrize(
+    'input_extensions, expected_metadata',
+    [
+        (
+            None,
+            [],
+        ),
+        (
+            ['ext2'],
+            [
+                (HTTP_EXTENSION_HEADER.lower(), 'ext2'),
+            ],
+        ),
+        (
+            ['ext2', 'ext3'],
+            [
+                (HTTP_EXTENSION_HEADER.lower(), 'ext2,ext3'),
+            ],
+        ),
+    ],
+)
+def test_get_grpc_metadata(
+    grpc_transport: GrpcTransport,
+    input_extensions: list[str] | None,
+    expected_metadata: list[tuple[str, str]] | None,
+) -> None:
+    """Tests _get_grpc_metadata for correct metadata generation."""
+    context = None
+    if input_extensions:
+        context = ClientCallContext(
+            service_parameters={
+                HTTP_EXTENSION_HEADER: ','.join(input_extensions)
+            }
+        )
+
+    metadata = grpc_transport._get_grpc_metadata(context)
+    # Filter out a2a-version as it's not being tested here directly and simplifies the assertion
+    filtered_metadata = [m for m in metadata if m[0] != VERSION_HEADER.lower()]
+    assert filtered_metadata == expected_metadata
diff --git a/tests/client/transports/test_http_helpers.py b/tests/client/transports/test_http_helpers.py
new file mode 100644
index 000000000..86d9591d1
--- /dev/null
+++ b/tests/client/transports/test_http_helpers.py
@@ -0,0 +1,169 @@
+from collections.abc import AsyncIterator
+
+import httpx
+import pytest
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.http_helpers import (
+    _SSEEventSource,
+    _default_sse_error_handler,
+    get_http_args,
+    parse_sse_stream,
+    send_http_stream_request,
+)
+
+
+def test_default_sse_error_handler():
+    with pytest.raises(
+        A2AClientError, match='SSE stream error event received: error_msg'
+    ):
+        _default_sse_error_handler('error_msg')
+
+
+@pytest.mark.asyncio
+async def test_parse_sse_stream_edge_cases():
+    async def mock_aiter_text():
+        yield ': comment line (should be ignored)\n'
+        yield 'event: custom_event\n'
+        yield 'data:  hello\n'
+        yield 'data: world\n'
+        yield '\n'
+        yield '\n'
+        yield 'data: \n'
+        yield '\n'
+
+    response = httpx.Response(200)
+    response.aiter_text = mock_aiter_text  # type: ignore
+
+    events = [e async for e in parse_sse_stream(response)]
+    assert events == [
+        ('custom_event', ' hello\nworld'),
+        ('message', ''),
+    ]
+
+
+async def _byte_chunks(chunks: list[bytes]) -> AsyncIterator[bytes]:
+    for chunk in chunks:
+        yield chunk
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('chunks', 'expected'),
+    [
+        pytest.param(
+            ['data: a
b
c\x85d\n\n'.encode()],
+            [('message', 'a
b
c\x85d')],
+            id='unicode-line-separators-stay-in-data',
+        ),
+        pytest.param(
+            [b'data: a\xe2\x80', b'\xa8b\r', b'\ndata: c\r\r'],
+            [('message', 'a
b\nc')],
+            id='crlf-and-character-split-across-chunks',
+        ),
+        pytest.param(
+            [b'data: a\r'],
+            [],
+            id='event-without-blank-line-is-not-dispatched',
+        ),
+    ],
+)
+async def test_parse_sse_stream_ends_lines_only_at_cr_or_lf(
+    chunks: list[bytes], expected: list[tuple[str, str]]
+) -> None:
+    """Only CRLF, LF and CR end a line, as the SSE specification requires."""
+    response = httpx.Response(200, content=_byte_chunks(chunks))
+
+    events = [e async for e in parse_sse_stream(response)]
+
+    assert events == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_parse_sse_stream_long_data_line_over_many_chunks() -> None:
+    """A multi-megabyte data: line read in small chunks stays linear."""
+    payload = 'x' * (2 * 1024 * 1024)
+    body = f'data: {payload}\r\n\r\n'.encode()
+    chunk_size = 512
+    chunks = [body[i : i + chunk_size] for i in range(0, len(body), chunk_size)]
+    response = httpx.Response(200, content=_byte_chunks(chunks))
+
+    # Re-joining and re-scanning the whole line on every chunk took tens of
+    # seconds here; the linear version takes well under a second.
+    events = [e async for e in parse_sse_stream(response)]
+
+    assert events == [('message', payload)]
+
+
+@pytest.mark.asyncio
+async def test_send_http_stream_request_non_sse(mocker):
+    client = httpx.AsyncClient()
+    request = httpx.Request('GET', 'http://test')
+    response = httpx.Response(
+        200,
+        headers={'Content-Type': 'application/json'},
+        content=b'plain error response',
+        request=request,
+    )
+
+    mocker.patch(
+        'a2a.client.transports.http_helpers._SSEEventSource.__aenter__',
+        return_value=response,
+    )
+    mocker.patch(
+        'a2a.client.transports.http_helpers._SSEEventSource.__aexit__',
+        return_value=None,
+    )
+
+    chunks = [
+        c async for c in send_http_stream_request(client, 'GET', 'http://test')
+    ]
+    assert chunks == ['plain error response']
+
+
+def test_get_http_args_passes_timeout_through_unwrapped():
+    """The timeout stays a bare float, for the client itself to wrap."""
+    http_kwargs = get_http_args(ClientCallContext(timeout=5.0))
+
+    assert http_kwargs['timeout'] == 5.0
+    assert not isinstance(http_kwargs['timeout'], httpx.Timeout)
+
+    request = httpx.AsyncClient().build_request(
+        'GET', 'http://test', **http_kwargs
+    )
+    assert request.extensions['timeout'] == {
+        'connect': 5.0,
+        'read': 5.0,
+        'write': 5.0,
+        'pool': 5.0,
+    }
+
+
+def test_sse_event_source_sets_default_stream_headers():
+    source = _SSEEventSource(httpx.AsyncClient(), 'GET', 'http://test')
+
+    assert source._request.headers['Accept'] == 'text/event-stream'
+    assert source._request.headers['Cache-Control'] == 'no-store'
+
+
+@pytest.mark.parametrize(
+    'caller_spelling', ['accept', 'Accept', 'ACCEPT', 'AcCePt']
+)
+def test_sse_event_source_keeps_caller_accept_whatever_its_case(
+    caller_spelling: str,
+):
+    """A caller's own Accept wins, and is never joined by a second one.
+
+    HTTP header names are case-insensitive, so matching the caller's
+    spelling exactly is not enough to detect that they already set one.
+    """
+    source = _SSEEventSource(
+        httpx.AsyncClient(),
+        'GET',
+        'http://test',
+        headers={caller_spelling: 'application/json'},
+    )
+
+    assert source._request.headers.get_list('accept') == ['application/json']
diff --git a/tests/client/transports/test_jsonrpc_client.py b/tests/client/transports/test_jsonrpc_client.py
new file mode 100644
index 000000000..0f49fbb7a
--- /dev/null
+++ b/tests/client/transports/test_jsonrpc_client.py
@@ -0,0 +1,975 @@
+"""Tests for the JSON-RPC client transport."""
+
+import json
+
+from collections.abc import AsyncGenerator
+from unittest.mock import AsyncMock, MagicMock, patch
+from uuid import uuid4
+
+import httpx
+import pytest
+
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.jsonrpc import JsonRpcTransport
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    Message,
+    Part,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SendMessageResponse,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+)
+from a2a.utils.errors import JSON_RPC_ERROR_CODE_MAP, TaskNotFoundError
+from google.protobuf import json_format
+
+
+async def async_iterable_from_list(
+    items: list[str],
+) -> AsyncGenerator[str, None]:
+    """Helper to create an async iterable from a list."""
+    for item in items:
+        yield item
+
+
+@pytest.fixture
+def mock_httpx_client():
+    """Creates a mock httpx.AsyncClient."""
+    client = AsyncMock(spec=httpx.AsyncClient)
+    client.is_closed = False
+    client.headers = httpx.Headers()
+    client.timeout = httpx.Timeout(30.0)
+    return client
+
+
+@pytest.fixture
+def agent_card():
+    """Creates a minimal AgentCard for testing."""
+    return AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://test-agent.example.com',
+                protocol_binding='HTTP+JSON',
+            )
+        ],
+        version='1.0.0',
+        capabilities=AgentCapabilities(),
+    )
+
+
+@pytest.fixture
+def transport(mock_httpx_client, agent_card):
+    """Creates a JsonRpcTransport instance for testing."""
+    return JsonRpcTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=agent_card,
+        url='http://test-agent.example.com',
+    )
+
+
+@pytest.fixture
+def transport_with_url(mock_httpx_client):
+    """Creates a JsonRpcTransport with just a URL."""
+    return JsonRpcTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=AgentCard(name='Dummy'),
+        url='http://custom-url.example.com',
+    )
+
+
+def create_send_message_request(text='Hello'):
+    """Helper to create a SendMessageRequest with proper proto structure."""
+    return SendMessageRequest(
+        message=Message(
+            role='ROLE_USER',
+            parts=[Part(text=text)],
+            message_id='msg-123',
+        ),
+        configuration=SendMessageConfiguration(),
+    )
+
+
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+
+
+def _assert_extensions_header(mock_kwargs: dict, expected_extensions: set[str]):
+    headers = mock_kwargs.get('headers', {})
+    assert HTTP_EXTENSION_HEADER in headers
+    header_value = headers[HTTP_EXTENSION_HEADER]
+    actual_extensions = {e.strip() for e in header_value.split(',')}
+    assert actual_extensions == expected_extensions
+
+
+class TestJsonRpcTransportInit:
+    """Tests for JsonRpcTransport initialization."""
+
+    def test_init_with_agent_card(self, mock_httpx_client, agent_card):
+        """Test initialization with an agent card."""
+        transport = JsonRpcTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://test-agent.example.com',
+        )
+        assert transport.url == 'http://test-agent.example.com'
+        assert transport.agent_card == agent_card
+
+
+class TestSendMessage:
+    """Tests for the send_message method."""
+
+    @pytest.mark.asyncio
+    async def test_send_message_success(self, transport, mock_httpx_client):
+        """Test successful message sending."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'task': {
+                    'id': task_id,
+                    'contextId': 'ctx-123',
+                    'status': {'state': 'TASK_STATE_COMPLETED'},
+                }
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = create_send_message_request()
+        response = await transport.send_message(request)
+
+        assert isinstance(response, SendMessageResponse)
+        mock_httpx_client.build_request.assert_called_once()
+        call_args = mock_httpx_client.build_request.call_args
+        assert call_args[0][1] == 'http://test-agent.example.com'
+        payload = call_args[1]['json']
+        assert payload['method'] == 'SendMessage'
+
+    @pytest.mark.parametrize(
+        'error_cls, error_code', JSON_RPC_ERROR_CODE_MAP.items()
+    )
+    @pytest.mark.asyncio
+    async def test_send_message_jsonrpc_error(
+        self, transport, mock_httpx_client, error_cls, error_code
+    ):
+        """Test handling of JSON-RPC mapped error response."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'error': {'code': error_code, 'message': 'Mapped Error'},
+            'result': None,
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = create_send_message_request()
+
+        # The transport raises the specific A2AError mapped from code
+        with pytest.raises(error_cls):
+            await transport.send_message(request)
+
+    @pytest.mark.asyncio
+    async def test_send_message_timeout(self, transport, mock_httpx_client):
+        """Test handling of request timeout."""
+        mock_httpx_client.send.side_effect = httpx.ReadTimeout('Timeout')
+
+        request = create_send_message_request()
+
+        with pytest.raises(A2AClientError, match='timed out'):
+            await transport.send_message(request)
+
+    @pytest.mark.asyncio
+    async def test_send_message_http_error(self, transport, mock_httpx_client):
+        """Test handling of HTTP errors."""
+        mock_response = MagicMock()
+        mock_response.status_code = 500
+        mock_httpx_client.send.side_effect = httpx.HTTPStatusError(
+            'Server Error', request=MagicMock(), response=mock_response
+        )
+
+        request = create_send_message_request()
+
+        with pytest.raises(A2AClientError):
+            await transport.send_message(request)
+
+    @pytest.mark.asyncio
+    async def test_send_message_json_decode_error(
+        self, transport, mock_httpx_client
+    ):
+        """Test handling of invalid JSON response."""
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json.side_effect = json.JSONDecodeError('msg', 'doc', 0)
+        mock_httpx_client.send.return_value = mock_response
+
+        request = create_send_message_request()
+
+        with pytest.raises(A2AClientError):
+            await transport.send_message(request)
+
+    @pytest.mark.asyncio
+    async def test_send_message_with_timeout_context(
+        self, transport, mock_httpx_client
+    ):
+        """Test that send_message passes context timeout to build_request."""
+        from a2a.client.client import ClientCallContext
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {},
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = create_send_message_request()
+        context = ClientCallContext(timeout=15.0)
+
+        await transport.send_message(request, context=context)
+
+        mock_httpx_client.build_request.assert_called_once()
+        _, kwargs = mock_httpx_client.build_request.call_args
+        assert 'timeout' in kwargs
+        assert kwargs['timeout'] == 15.0
+
+
+class TestGetTask:
+    """Tests for the get_task method."""
+
+    @pytest.mark.asyncio
+    async def test_get_task_success(self, transport, mock_httpx_client):
+        """Test successful task retrieval."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'id': task_id,
+                'contextId': 'ctx-123',
+                'status': {'state': 'TASK_STATE_COMPLETED'},
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        # Proto uses 'name' field for task identifier in request
+        request = GetTaskRequest(id=f'{task_id}')
+        response = await transport.get_task(request)
+
+        assert isinstance(response, Task)
+        assert response.id == task_id
+        mock_httpx_client.build_request.assert_called_once()
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['method'] == 'GetTask'
+
+    @pytest.mark.asyncio
+    async def test_get_task_with_history(self, transport, mock_httpx_client):
+        """Test task retrieval with history_length parameter."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'id': task_id,
+                'contextId': 'ctx-123',
+                'status': {'state': 'TASK_STATE_COMPLETED'},
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = GetTaskRequest(id=f'{task_id}', history_length=10)
+        response = await transport.get_task(request)
+
+        assert isinstance(response, Task)
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['params']['historyLength'] == 10
+
+
+class TestCancelTask:
+    """Tests for the cancel_task method."""
+
+    @pytest.mark.asyncio
+    async def test_cancel_task_success(self, transport, mock_httpx_client):
+        """Test successful task cancellation."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'id': task_id,
+                'contextId': 'ctx-123',
+                'status': {'state': 5},  # TASK_STATE_CANCELED = 5
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = CancelTaskRequest(id=f'{task_id}')
+        response = await transport.cancel_task(request)
+
+        assert isinstance(response, Task)
+        assert response.status.state == TaskState.TASK_STATE_CANCELED
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['method'] == 'CancelTask'
+
+
+class TestTaskCallback:
+    """Tests for the task callback methods."""
+
+    @pytest.mark.asyncio
+    async def test_get_task_push_notification_config_success(
+        self, transport, mock_httpx_client
+    ):
+        """Test successful task callback retrieval."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'task_id': f'{task_id}',
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = GetTaskPushNotificationConfigRequest(
+            task_id=f'{task_id}',
+            id='config-1',
+        )
+        response = await transport.get_task_push_notification_config(request)
+
+        assert isinstance(response, TaskPushNotificationConfig)
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['method'] == 'GetTaskPushNotificationConfig'
+
+    @pytest.mark.asyncio
+    async def test_list_task_push_notification_configs_success(
+        self, transport, mock_httpx_client
+    ):
+        """Test successful task multiple callbacks retrieval."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'configs': [
+                    {
+                        'task_id': f'{task_id}',
+                        'id': 'config-1',
+                        'url': 'https://example.com',
+                    }
+                ]
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = ListTaskPushNotificationConfigsRequest(
+            task_id=f'{task_id}',
+        )
+        response = await transport.list_task_push_notification_configs(request)
+
+        assert len(response.configs) == 1
+        assert response.configs[0].task_id == task_id
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['method'] == 'ListTaskPushNotificationConfigs'
+
+    @pytest.mark.asyncio
+    async def test_delete_task_push_notification_config_success(
+        self, transport, mock_httpx_client
+    ):
+        """Test successful task callback deletion."""
+        task_id = str(uuid4())
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'task_id': f'{task_id}',
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = DeleteTaskPushNotificationConfigRequest(
+            task_id=f'{task_id}',
+            id='config-1',
+        )
+        response = await transport.delete_task_push_notification_config(request)
+
+        mock_httpx_client.build_request.assert_called_once()
+        assert response is None
+        call_args = mock_httpx_client.build_request.call_args
+        payload = call_args[1]['json']
+        assert payload['method'] == 'DeleteTaskPushNotificationConfig'
+
+
+class TestClose:
+    """Tests for the close method."""
+
+    @pytest.mark.asyncio
+    async def test_close(self, transport, mock_httpx_client):
+        """Test that close properly closes the httpx client."""
+        await transport.close()
+
+
+class TestStreamingErrors:
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_sse_error(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        transport: JsonRpcTransport,
+    ):
+        request = create_send_message_request()
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            ['event: error\ndata: Simulated SSE error\n\n']
+        )
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError):
+            async for _ in transport.send_message_streaming(request):
+                pass
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_request_error(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        transport: JsonRpcTransport,
+    ):
+        request = create_send_message_request()
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.side_effect = httpx.RequestError(
+            'Simulated request error', request=MagicMock()
+        )
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError):
+            async for _ in transport.send_message_streaming(request):
+                pass
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_timeout(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        transport: JsonRpcTransport,
+    ):
+        request = create_send_message_request()
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.side_effect = httpx.TimeoutException('Timeout')
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError, match='timed out'):
+            async for _ in transport.send_message_streaming(request):
+                pass
+
+
+class TestInterceptors:
+    """Tests for interceptor functionality."""
+
+
+class TestExtensions:
+    """Tests for extension header functionality."""
+
+    @pytest.mark.asyncio
+    async def test_extensions_added_to_request(
+        self, mock_httpx_client, agent_card
+    ):
+        """Test that extensions are added to request headers."""
+        transport = JsonRpcTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://test-agent.example.com',
+        )
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'task': {
+                    'id': 'task-123',
+                    'contextId': 'ctx-123',
+                    'status': {'state': 'TASK_STATE_COMPLETED'},
+                }
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        request = create_send_message_request()
+
+        from a2a.client.client import ClientCallContext
+
+        context = ClientCallContext(
+            service_parameters={'A2A-Extensions': 'https://example.com/ext1'}
+        )
+
+        await transport.send_message(request, context=context)
+
+        # Verify request was made with extension headers
+        mock_httpx_client.build_request.assert_called_once()
+        call_args = mock_httpx_client.build_request.call_args
+        # Extensions should be in the kwargs
+        assert (
+            call_args[1].get('headers', {}).get('A2A-Extensions')
+            == 'https://example.com/ext1'
+        )
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_server_error_propagates(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        agent_card: AgentCard,
+    ):
+        """Test that send_message_streaming propagates server errors (e.g., 403, 500) directly."""
+        client = JsonRpcTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://test-agent.example.com',
+        )
+        request = create_send_message_request(text='Error stream')
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 403
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            'Forbidden',
+            request=httpx.Request('POST', 'http://test.url'),
+            response=mock_response,
+        )
+        mock_response.aiter_text.return_value = async_iterable_from_list([])
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError) as exc_info:
+            async for _ in client.send_message_streaming(request=request):
+                pass
+
+        assert 'HTTP Error 403' in str(exc_info.value)
+        mock_aconnect_sse.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_card_with_extended_card_support_with_extensions(
+        self, mock_httpx_client: AsyncMock, agent_card: AgentCard
+    ):
+        """Test get_extended_agent_card with extensions passed to call when extended card support is enabled.
+        Tests that the extensions are added to the RPC request."""
+        extensions_header_val = (
+            'https://example.com/test-ext/v1,https://example.com/test-ext/v2'
+        )
+        agent_card.capabilities.extended_agent_card = True
+
+        client = JsonRpcTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://test-agent.example.com',
+        )
+
+        extended_card = AgentCard()
+        extended_card.CopyFrom(agent_card)
+        extended_card.name = 'Extended'
+
+        request = GetExtendedAgentCardRequest()
+        rpc_response = {
+            'id': '123',
+            'jsonrpc': '2.0',
+            'result': json_format.MessageToDict(extended_card),
+        }
+
+        from a2a.client.client import ClientCallContext
+
+        context = ClientCallContext(
+            service_parameters={HTTP_EXTENSION_HEADER: extensions_header_val}
+        )
+
+        with patch.object(
+            client, '_send_request', new_callable=AsyncMock
+        ) as mock_send_request:
+            mock_send_request.return_value = rpc_response
+            await client.get_extended_agent_card(request, context=context)
+
+        mock_send_request.assert_called_once()
+        _, mock_kwargs = mock_send_request.call_args[0]
+
+        # _send_request receives context as second arg OR http_kwargs if mocked lower level?
+        # In implementation: await self._send_request(rpc_request.data, context)
+        # So mocks should see context.
+        # Wait, the test asserts _send_request call args.
+        assert mock_kwargs == context
+
+        # But verify headers are IN context or processed later?
+        # send_request calls _get_http_args(context)
+        # The test originally verified: _assert_extensions_header(mock_kwargs, ...)
+        # But mock_kwargs here is the 2nd argument to _send_request which IS context.
+        # The original test mocked _send_request?
+        # Let's check original test.
+        # "with patch.object(client, '_send_request', ...)"
+        # "mock_send_request.assert_called_once()"
+        # "_, mock_kwargs = mock_send_request.call_args[0]"
+        # The args to _send_request are (self, payload, context).
+        # So mock_kwargs is CONTEXT.
+        # The original assertion _assert_extensions_header checked mock_kwargs.get('headers').
+        # DOES context have headers/get method? No.
+        # So the original test was mocking _send_request but maybe assuming it was modifying kwargs or similar?
+        # No, _send_request signature is (payload, context).
+        # Ah, maybe I should check what _send_request DOES implicitly?
+        # Or maybe test was testing logic INSIDE _send_request but mocking it? That defeats the purpose.
+        # Ah, original test: `client = JsonRpcTransport(...)`
+        # `await client.get_extended_agent_card(request, extensions=extensions)`
+        # The client calls `await self._send_request(rpc_request.data, context)`.
+        # So calling `_send_request` mock.
+        # The original test verified `mock_kwargs`.
+        # Maybe the original `get_extended_agent_card` constructed `http_kwargs` and passed it?
+        # In original code (which I can't see but guess), maybe `get_extended_agent_card` computed extensions headers?
+
+        # In current implementation (Step 480):
+        # get_extended_agent_card calls `await self._send_request(rpc_request.data, context)`
+        # It does NOT inspect extensions.
+        # So verifying `mock_kwargs` (which is context) is useless for headers unless context has them.
+        # But I'm creating context with headers in service_parameters.
+        # So I can verify context has expected service_parameters.
+
+        assert mock_kwargs.service_parameters == {
+            HTTP_EXTENSION_HEADER: extensions_header_val
+        }
+
+
+class TestCreateJsonRpcError:
+    """Unit tests for JsonRpcTransport._create_jsonrpc_error."""
+
+    @pytest.fixture
+    def transport(self, mock_httpx_client, agent_card):
+        return JsonRpcTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://test-agent.example.com',
+        )
+
+    def test_lifts_error_info_metadata_onto_a2a_error_data(
+        self, transport
+    ) -> None:
+        """New spec format: ErrorInfo.metadata is exposed as A2AError.data."""
+        from a2a.utils.errors import TaskNotFoundError
+
+        exc = transport._create_jsonrpc_error(
+            {
+                'code': -32001,
+                'message': 'Task not found',
+                'data': [
+                    {
+                        '@type': ('type.googleapis.com/google.rpc.ErrorInfo'),
+                        'reason': 'TASK_NOT_FOUND',
+                        'domain': 'a2a-protocol.org',
+                        'metadata': {'taskId': 'abc-123'},
+                    }
+                ],
+            }
+        )
+        assert isinstance(exc, TaskNotFoundError)
+        assert exc.message == 'Task not found'
+        assert exc.data == {'taskId': 'abc-123'}
+
+    def test_no_data_field_yields_none_data(self, transport) -> None:
+        from a2a.utils.errors import InternalError
+
+        exc = transport._create_jsonrpc_error(
+            {'code': -32603, 'message': 'oops'}
+        )
+        assert isinstance(exc, InternalError)
+        assert exc.data is None
+
+    def test_array_without_error_info_yields_none_data(self, transport) -> None:
+        """A details array carrying only BadRequest (no ErrorInfo) yields None."""
+        from a2a.utils.errors import InvalidParamsError
+
+        exc = transport._create_jsonrpc_error(
+            {
+                'code': -32602,
+                'message': 'bad params',
+                'data': [
+                    {
+                        '@type': ('type.googleapis.com/google.rpc.BadRequest'),
+                        'fieldViolations': [],
+                    }
+                ],
+            }
+        )
+        assert isinstance(exc, InvalidParamsError)
+        assert exc.data is None
+
+    def test_unknown_code_falls_back_to_a2a_client_error(
+        self, transport
+    ) -> None:
+        exc = transport._create_jsonrpc_error(
+            {'code': -42, 'message': 'who knows'}
+        )
+        assert isinstance(exc, A2AClientError)
+        assert 'JSON-RPC Error -42' in str(exc)
+
+    def test_json_parse_error_is_typed(self, transport) -> None:
+        """JSON-RPC -32700 must map to a typed JSONParseError exception (not
+        the generic A2AClientError fallback)."""
+        from a2a.utils.errors import JSONParseError
+
+        exc = transport._create_jsonrpc_error(
+            {'code': -32700, 'message': 'Invalid JSON payload'}
+        )
+        assert isinstance(exc, JSONParseError)
+        assert exc.message == 'Invalid JSON payload'
+
+
+class TestUnrecognizedResponseFields:
+    """Spec 5.7: unrecognized response fields are ignored (issue #1341)."""
+
+    @pytest.mark.asyncio
+    async def test_get_task_ignores_unrecognized_fields(
+        self, transport, mock_httpx_client
+    ):
+        """Unknown keys are skipped at every depth; known ones still parse."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'id': 'task-1',
+                'contextId': 'ctx-1',
+                'status': {
+                    'state': 'TASK_STATE_COMPLETED',
+                    'someNestedField': 'y',
+                },
+                'someNewField': 'x',
+            },
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        task = await transport.get_task(GetTaskRequest(id='task-1'))
+
+        assert task.id == 'task-1'
+        assert task.context_id == 'ctx-1'
+        assert task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_ignores_unrecognized_fields(
+        self, mock_sse_source: AsyncMock, transport
+    ):
+        """The streamed branch is as lenient as the unary one."""
+        payload = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': {
+                'message': {
+                    'messageId': 'r1',
+                    'role': 'ROLE_AGENT',
+                    'parts': [{'text': 'hello'}],
+                },
+                'someNewField': 'x',
+            },
+        }
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            [f'data: {json.dumps(payload)}\n\n']
+        )
+        mock_sse_source.return_value.__aenter__.return_value = mock_response
+
+        events = [
+            event
+            async for event in transport.send_message_streaming(
+                create_send_message_request()
+            )
+        ]
+
+        assert len(events) == 1
+        assert events[0].message.message_id == 'r1'
+        assert events[0].message.parts[0].text == 'hello'
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize('result', [[], None])
+    async def test_get_task_rejects_result_that_is_not_an_object(
+        self, transport, mock_httpx_client, result
+    ):
+        """A non-object result is not read as an empty Task."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'result': result,
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        with pytest.raises(json_format.ParseError, match='JSON object'):
+            await transport.get_task(GetTaskRequest(id='task-1'))
+
+
+# A JSON-RPC error object with a member beyond code, message and data.
+_ERROR_WITH_EXTRA_MEMBER = {
+    'jsonrpc': '2.0',
+    'id': '1',
+    'error': {'code': -32001, 'message': 'Task not found', 'reason': 'x'},
+}
+
+
+class TestMalformedJsonRpcResponses:
+    """Responses that are not valid JSON-RPC 2.0 raise A2A errors.
+
+    The transport used to build ``JSONRPC20Response`` objects from the raw
+    body, so these responses leaked ``TypeError``/``ValueError`` from the
+    ``json-rpc`` package instead of an ``A2AClientError``.
+    """
+
+    @pytest.mark.parametrize(
+        'body',
+        [
+            pytest.param(
+                [{'jsonrpc': '2.0', 'id': '1', 'result': {}}], id='list'
+            ),
+            pytest.param('Bad Gateway', id='string'),
+            pytest.param(
+                {'jsonrpc': '2.0', 'id': '1'}, id='no-result-or-error'
+            ),
+            pytest.param(
+                {'jsonrpc': '2.0', 'id': '1', 'error': 'boom'},
+                id='error-not-an-object',
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_invalid_envelope_raises_client_error(
+        self, transport, mock_httpx_client, body
+    ):
+        mock_response = MagicMock()
+        mock_response.json.return_value = body
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        with pytest.raises(A2AClientError, match='Invalid JSON-RPC response'):
+            await transport.get_task(GetTaskRequest(id='task-1'))
+
+    @pytest.mark.parametrize(
+        'error',
+        [
+            pytest.param(_ERROR_WITH_EXTRA_MEMBER['error'], id='extra-member'),
+            pytest.param({'code': -32001}, id='no-message'),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_nonstandard_error_object_maps_to_a2a_error(
+        self, transport, mock_httpx_client, error
+    ):
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'error': error,
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        with pytest.raises(TaskNotFoundError):
+            await transport.get_task(GetTaskRequest(id='task-1'))
+
+    @pytest.mark.asyncio
+    async def test_delete_push_config_error_still_raises(
+        self, transport, mock_httpx_client
+    ):
+        """The delete call ignores the result but must still raise errors."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'error': {'code': -32001, 'message': 'Task not found'},
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_httpx_client.send.return_value = mock_response
+
+        with pytest.raises(TaskNotFoundError):
+            await transport.delete_task_push_notification_config(
+                DeleteTaskPushNotificationConfigRequest(
+                    task_id='task-1', id='config-1'
+                )
+            )
+
+    @pytest.mark.parametrize(
+        ('lines', 'expected_error'),
+        [
+            pytest.param(['data: not json', ''], A2AClientError, id='not-json'),
+            pytest.param(
+                [f'data: {json.dumps({"jsonrpc": "2.0", "id": "1"})}', ''],
+                A2AClientError,
+                id='no-result-or-error',
+            ),
+            pytest.param(
+                [f'data: {json.dumps(_ERROR_WITH_EXTRA_MEMBER)}', ''],
+                TaskNotFoundError,
+                id='error-extra-member',
+            ),
+            pytest.param(
+                [
+                    'event: error',
+                    f'data: {json.dumps(_ERROR_WITH_EXTRA_MEMBER)}',
+                    '',
+                ],
+                TaskNotFoundError,
+                id='error-event-extra-member',
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_streaming_malformed_event_raises_a2a_error(
+        self, mock_sse_source: AsyncMock, transport, lines, expected_error
+    ):
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            [f'{line}\n' for line in lines]
+        )
+        mock_sse_source.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(expected_error):
+            async for _ in transport.send_message_streaming(
+                create_send_message_request()
+            ):
+                pass
diff --git a/tests/client/transports/test_rest_client.py b/tests/client/transports/test_rest_client.py
new file mode 100644
index 000000000..a75aafc3c
--- /dev/null
+++ b/tests/client/transports/test_rest_client.py
@@ -0,0 +1,1111 @@
+import json
+
+from collections.abc import AsyncGenerator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.client.client import ClientCallContext
+from a2a.client.errors import A2AClientError
+from a2a.client.transports.rest import RestTransport
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.helpers.proto_helpers import new_text_message
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_rest_routes
+from a2a.server.tasks import (
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+from a2a.utils.constants import (
+    PROTOCOL_VERSION_CURRENT,
+    VERSION_HEADER,
+    TransportProtocol,
+)
+from a2a.utils.errors import (
+    A2A_ERROR_MAPPING,
+    MethodNotFoundError,
+    TaskNotFoundError,
+)
+from google.protobuf import json_format
+from google.protobuf.timestamp_pb2 import Timestamp
+from starlette.applications import Starlette
+
+
+@pytest.fixture
+def mock_httpx_client() -> AsyncMock:
+    client = AsyncMock(spec=httpx.AsyncClient)
+    client.is_closed = False
+    return client
+
+
+@pytest.fixture
+def mock_agent_card() -> MagicMock:
+    mock = MagicMock(spec=AgentCard, url='http://agent.example.com/api')
+    mock.supported_interfaces = [
+        AgentInterface(
+            protocol_binding=TransportProtocol.HTTP_JSON,
+            url='http://agent.example.com/api',
+        )
+    ]
+    mock.capabilities = MagicMock()
+    mock.capabilities.extended_agent_card = False
+    return mock
+
+
+async def async_iterable_from_list(
+    items: list[str],
+) -> AsyncGenerator[str, None]:
+    """Helper to create an async iterable from a list."""
+    for item in items:
+        yield item
+
+
+def _assert_extensions_header(mock_kwargs: dict, expected_extensions: set[str]):
+    headers = mock_kwargs.get('headers', {})
+    assert HTTP_EXTENSION_HEADER in headers
+    header_value = headers[HTTP_EXTENSION_HEADER]
+    actual_extensions = {e.strip() for e in header_value.split(',')}
+    assert actual_extensions == expected_extensions
+
+
+class TestRestTransport:
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_timeout(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+    ):
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        params = SendMessageRequest(
+            message=new_text_message(text='Hello stream')
+        )
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.raise_for_status.return_value = None
+        mock_response.aiter_text.side_effect = httpx.TimeoutException(
+            'Read timed out'
+        )
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError) as exc_info:
+            _ = [
+                item
+                async for item in client.send_message_streaming(request=params)
+            ]
+
+        assert 'Client Request timed out' in str(exc_info.value)
+
+    @pytest.mark.parametrize('error_cls', list(A2A_ERROR_MAPPING.keys()))
+    @pytest.mark.asyncio
+    async def test_rest_mapped_errors(
+        self,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+        error_cls,
+    ):
+        """Test handling of mapped REST HTTP error responses."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        params = SendMessageRequest(message=new_text_message(text='Hello'))
+
+        mock_build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_httpx_client.build_request = mock_build_request
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 500
+
+        reason = A2A_ERROR_MAPPING[error_cls][2]
+
+        mock_response.json.return_value = {
+            'error': {
+                'code': 500,
+                'status': 'UNKNOWN',
+                'message': 'Mapped Error',
+                'details': [
+                    {
+                        '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                        'reason': reason,
+                        'domain': 'a2a-protocol.org',
+                        'metadata': {},
+                    }
+                ],
+            }
+        }
+
+        error = httpx.HTTPStatusError(
+            'Server Error',
+            request=httpx.Request('POST', 'http://test.url'),
+            response=mock_response,
+        )
+
+        mock_httpx_client.send.side_effect = error
+
+        with pytest.raises(error_cls):
+            await client.send_message(request=params)
+
+    @pytest.mark.parametrize(
+        ('status_code', 'body', 'expected_error'),
+        [
+            (401, {'error': 'invalid_token'}, A2AClientError),
+            (404, {'error': 'Not Found'}, MethodNotFoundError),
+            (502, ['bad gateway'], A2AClientError),
+            (500, 'Internal Server Error', A2AClientError),
+            (503, None, A2AClientError),
+        ],
+    )
+    def test_rest_non_status_error_bodies(
+        self,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+        status_code,
+        body,
+        expected_error,
+    ):
+        """JSON error bodies that are not a google.rpc.Status (e.g. from a proxy) fall back to the HTTP status."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = status_code
+        mock_response.json.return_value = body
+        error = httpx.HTTPStatusError(
+            'Error',
+            request=httpx.Request('GET', 'http://test.url'),
+            response=mock_response,
+        )
+
+        with pytest.raises(expected_error):
+            client._handle_http_error(error)
+
+    @pytest.mark.asyncio
+    async def test_send_message_with_timeout_context(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Test that send_message passes context timeout to build_request."""
+
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        params = SendMessageRequest(message=new_text_message(text='Hello'))
+        context = ClientCallContext(timeout=10.0)
+
+        mock_build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_httpx_client.build_request = mock_build_request
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json = MagicMock(return_value={})
+        mock_httpx_client.send.return_value = mock_response
+
+        await client.send_message(request=params, context=context)
+
+        mock_build_request.assert_called_once()
+        _, kwargs = mock_build_request.call_args
+        assert 'timeout' in kwargs
+        assert kwargs['timeout'] == 10.0
+
+    @pytest.mark.asyncio
+    async def test_url_serialization(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Test that query parameters are correctly serialized to the URL."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        timestamp = Timestamp()
+        timestamp.FromJsonString('2024-03-09T16:00:00Z')
+
+        request = ListTasksRequest(
+            tenant='my-tenant',
+            status=TaskState.TASK_STATE_WORKING,
+            include_artifacts=True,
+            status_timestamp_after=timestamp,
+        )
+
+        # Use real build_request to get actual URL serialization
+        mock_httpx_client.build_request.side_effect = (
+            httpx.AsyncClient().build_request
+        )
+        mock_httpx_client.send.return_value = AsyncMock(
+            spec=httpx.Response, status_code=200, json=lambda: {'tasks': []}
+        )
+
+        await client.list_tasks(request=request)
+
+        mock_httpx_client.send.assert_called_once()
+        sent_request = mock_httpx_client.send.call_args[0][0]
+
+        # Check decoded query parameters for spec compliance
+        params = sent_request.url.params
+        assert params['status'] == 'TASK_STATE_WORKING'
+        assert params['includeArtifacts'] == 'true'
+        assert params['statusTimestampAfter'] == '2024-03-09T16:00:00Z'
+        assert 'tenant' not in params
+
+
+class TestRestTransportExtensions:
+    @pytest.mark.asyncio
+    async def test_send_message_with_default_extensions(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Test that send_message adds extensions to headers."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        params = SendMessageRequest(message=new_text_message(text='Hello'))
+
+        # Mock the build_request method to capture its inputs
+        mock_build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_httpx_client.build_request = mock_build_request
+
+        # Mock the send method
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json = MagicMock(return_value={})
+        mock_httpx_client.send.return_value = mock_response
+
+        context = ClientCallContext(
+            service_parameters={
+                'A2A-Extensions': 'https://example.com/test-ext/v1,https://example.com/test-ext/v2'
+            }
+        )
+        await client.send_message(request=params, context=context)
+
+        mock_build_request.assert_called_once()
+        _, kwargs = mock_build_request.call_args
+
+        _assert_extensions_header(
+            kwargs,
+            {
+                'https://example.com/test-ext/v1',
+                'https://example.com/test-ext/v2',
+            },
+        )
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_with_new_extensions(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+    ):
+        """Test A2A-Extensions header in send_message_streaming."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        params = SendMessageRequest(
+            message=new_text_message(text='Hello stream')
+        )
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.raise_for_status.return_value = None
+        mock_response.aiter_text.return_value = async_iterable_from_list([])
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        context = ClientCallContext(
+            service_parameters={
+                'A2A-Extensions': 'https://example.com/test-ext/v2'
+            }
+        )
+
+        async for _ in client.send_message_streaming(
+            request=params, context=context
+        ):
+            pass
+
+        mock_aconnect_sse.assert_called_once()
+        _, kwargs = mock_aconnect_sse.call_args
+
+        _assert_extensions_header(
+            kwargs,
+            {
+                'https://example.com/test-ext/v2',
+            },
+        )
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_server_error_propagates(
+        self,
+        mock_aconnect_sse: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+    ):
+        """Test that send_message_streaming propagates server errors (e.g., 403, 500) directly."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        request = SendMessageRequest(
+            message=new_text_message(text='Error stream')
+        )
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 403
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            'Forbidden',
+            request=httpx.Request('POST', 'http://test.url'),
+            response=mock_response,
+        )
+        mock_response.aiter_text.return_value = async_iterable_from_list([])
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(A2AClientError) as exc_info:
+            async for _ in client.send_message_streaming(request=request):
+                pass
+
+        assert 'HTTP Error 403' in str(exc_info.value)
+
+        mock_aconnect_sse.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_card_with_extended_card_support_with_extensions(
+        self, mock_httpx_client: AsyncMock
+    ):
+        """Test get_extended_agent_card with extensions passed to  call when extended card support is enabled.
+        Tests that the extensions are added to the GET request."""
+        extensions_str = (
+            'https://example.com/test-ext/v1,https://example.com/test-ext/v2'
+        )
+        agent_card = AgentCard(
+            name='Test Agent',
+            description='Test Agent Description',
+            version='1.0.0',
+            capabilities=AgentCapabilities(extended_agent_card=True),
+        )
+        interface = agent_card.supported_interfaces.add()
+        interface.protocol_binding = TransportProtocol.HTTP_JSON
+        interface.url = 'http://agent.example.com/api'
+
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json.return_value = json_format.MessageToDict(
+            agent_card
+        )  # Extended card same for mock
+        mock_httpx_client.send.return_value = mock_response
+
+        request = GetExtendedAgentCardRequest()
+
+        context = ClientCallContext(
+            service_parameters={HTTP_EXTENSION_HEADER: extensions_str}
+        )
+
+        with patch.object(
+            client, '_execute_request', new_callable=AsyncMock
+        ) as mock_execute_request:
+            mock_execute_request.return_value = json_format.MessageToDict(
+                agent_card
+            )
+            await client.get_extended_agent_card(request, context=context)
+
+        mock_execute_request.assert_called_once()
+        call_args = mock_execute_request.call_args
+        assert (
+            call_args[1].get('context') == context or call_args[0][3] == context
+        )
+
+        _context = call_args[1].get('context') or call_args[0][3]
+        assert _context.service_parameters == {
+            HTTP_EXTENSION_HEADER: extensions_str
+        }
+
+
+class TestTaskCallback:
+    """Tests for the task callback methods."""
+
+    @pytest.mark.asyncio
+    async def test_list_task_push_notification_configs_success(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Test successful task multiple callbacks retrieval."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        task_id = 'task-1'
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            'configs': [
+                {
+                    'taskId': task_id,
+                    'id': 'config-1',
+                    'url': 'https://example.com',
+                }
+            ]
+        }
+        mock_httpx_client.send.return_value = mock_response
+
+        # Mock the build_request method to capture its inputs
+        mock_build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_httpx_client.build_request = mock_build_request
+
+        request = ListTaskPushNotificationConfigsRequest(
+            task_id=task_id,
+        )
+        response = await client.list_task_push_notification_configs(request)
+
+        assert len(response.configs) == 1
+        assert response.configs[0].task_id == task_id
+
+        mock_build_request.assert_called_once()
+        call_args = mock_build_request.call_args
+        assert call_args[0][0] == 'GET'
+        assert f'/tasks/{task_id}/pushNotificationConfigs' in call_args[0][1]
+
+    @pytest.mark.asyncio
+    async def test_delete_task_push_notification_config_success(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Test successful task callback deletion."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        task_id = 'task-1'
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json.return_value = {}
+        mock_httpx_client.send.return_value = mock_response
+
+        # Mock the build_request method to capture its inputs
+        mock_build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_httpx_client.build_request = mock_build_request
+
+        request = DeleteTaskPushNotificationConfigRequest(
+            task_id=task_id,
+            id='config-1',
+        )
+        await client.delete_task_push_notification_config(request)
+
+        mock_build_request.assert_called_once()
+        call_args = mock_build_request.call_args
+        assert call_args[0][0] == 'DELETE'
+        assert (
+            f'/tasks/{task_id}/pushNotificationConfigs/config-1'
+            in call_args[0][1]
+        )
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ('status_code', 'content'),
+        [(200, b'{}'), (204, b''), (200, b'')],
+        ids=['json_object', 'no_content', 'empty_200'],
+    )
+    async def test_delete_task_push_notification_config_ignores_body(
+        self, mock_agent_card: MagicMock, status_code: int, content: bytes
+    ):
+        """Servers confirm a deletion with `{}`, 204, or a 200 with no body."""
+        transport = httpx.MockTransport(
+            lambda request: httpx.Response(status_code, content=content)
+        )
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            client = RestTransport(
+                httpx_client=http_client,
+                agent_card=mock_agent_card,
+                url='http://agent.example.com/api',
+            )
+            await client.delete_task_push_notification_config(
+                DeleteTaskPushNotificationConfigRequest(
+                    task_id='task-1', id='config-1'
+                )
+            )
+
+    @pytest.mark.asyncio
+    async def test_delete_task_push_notification_config_maps_errors(
+        self, mock_agent_card: MagicMock
+    ):
+        """An error response still raises the mapped A2A error."""
+        body = {
+            'error': {
+                'code': 404,
+                'status': 'NOT_FOUND',
+                'message': 'Task task-1 not found',
+                'details': [
+                    {
+                        '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                        'reason': 'TASK_NOT_FOUND',
+                        'domain': 'a2a-protocol.org',
+                    }
+                ],
+            }
+        }
+        transport = httpx.MockTransport(
+            lambda request: httpx.Response(404, json=body)
+        )
+        async with httpx.AsyncClient(transport=transport) as http_client:
+            client = RestTransport(
+                httpx_client=http_client,
+                agent_card=mock_agent_card,
+                url='http://agent.example.com/api',
+            )
+            with pytest.raises(TaskNotFoundError):
+                await client.delete_task_push_notification_config(
+                    DeleteTaskPushNotificationConfigRequest(
+                        task_id='task-1', id='config-1'
+                    )
+                )
+
+    @pytest.mark.asyncio
+    async def test_delete_task_push_notification_config_closed_client(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """A closed HTTP client raises before anything is sent."""
+        mock_httpx_client.is_closed = True
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        with pytest.raises(A2AClientError, match='HTTP client is closed'):
+            await client.delete_task_push_notification_config(
+                DeleteTaskPushNotificationConfigRequest(
+                    task_id='task-1', id='config-1'
+                )
+            )
+
+        mock_httpx_client.send.assert_not_called()
+
+
+class TestRestTransportTenant:
+    """Tests for tenant path prepending in RestTransport."""
+
+    @pytest.mark.parametrize(
+        'method_name, request_obj, expected_path',
+        [
+            (
+                'send_message',
+                SendMessageRequest(
+                    tenant='my-tenant',
+                    message=new_text_message(text='hi'),
+                ),
+                '/my-tenant/message:send',
+            ),
+            (
+                'list_tasks',
+                ListTasksRequest(tenant='my-tenant'),
+                '/my-tenant/tasks',
+            ),
+            (
+                'get_task',
+                GetTaskRequest(tenant='my-tenant', id='task-123'),
+                '/my-tenant/tasks/task-123',
+            ),
+            (
+                'cancel_task',
+                CancelTaskRequest(tenant='my-tenant', id='task-123'),
+                '/my-tenant/tasks/task-123:cancel',
+            ),
+            (
+                'create_task_push_notification_config',
+                TaskPushNotificationConfig(
+                    tenant='my-tenant', task_id='task-123'
+                ),
+                '/my-tenant/tasks/task-123/pushNotificationConfigs',
+            ),
+            (
+                'get_task_push_notification_config',
+                GetTaskPushNotificationConfigRequest(
+                    tenant='my-tenant', task_id='task-123', id='cfg-1'
+                ),
+                '/my-tenant/tasks/task-123/pushNotificationConfigs/cfg-1',
+            ),
+            (
+                'list_task_push_notification_configs',
+                ListTaskPushNotificationConfigsRequest(
+                    tenant='my-tenant', task_id='task-123'
+                ),
+                '/my-tenant/tasks/task-123/pushNotificationConfigs',
+            ),
+            (
+                'delete_task_push_notification_config',
+                DeleteTaskPushNotificationConfigRequest(
+                    tenant='my-tenant', task_id='task-123', id='cfg-1'
+                ),
+                '/my-tenant/tasks/task-123/pushNotificationConfigs/cfg-1',
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_rest_methods_prepend_tenant(
+        self,
+        method_name,
+        request_obj,
+        expected_path,
+        mock_httpx_client,
+        mock_agent_card,
+    ):
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        # 1. Get the method dynamically
+        method = getattr(client, method_name)
+
+        # 2. Setup mocks
+        mock_httpx_client.build_request.return_value = MagicMock(
+            spec=httpx.Request
+        )
+        mock_httpx_client.send.return_value = AsyncMock(
+            spec=httpx.Response,
+            status_code=200,
+            json=MagicMock(return_value={}),
+        )
+
+        # 3. Call the method
+        await method(request=request_obj)
+
+        # 4. Verify the URL
+        args, _ = mock_httpx_client.build_request.call_args
+        assert args[1] == f'http://agent.example.com/api{expected_path}'
+
+    @pytest.mark.asyncio
+    async def test_rest_get_extended_agent_card_prepend_tenant(
+        self,
+        mock_httpx_client,
+        mock_agent_card,
+    ):
+        mock_agent_card.capabilities.extended_agent_card = True
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        request = GetExtendedAgentCardRequest(tenant='my-tenant')
+
+        # 1. Setup mocks
+        mock_httpx_client.build_request.return_value = MagicMock(
+            spec=httpx.Request
+        )
+        mock_httpx_client.send.return_value = AsyncMock(
+            spec=httpx.Response,
+            status_code=200,
+            json=MagicMock(return_value={}),
+        )
+
+        # 2. Call the method
+        await client.get_extended_agent_card(request=request)
+
+        # 3. Verify the URL
+        args, _ = mock_httpx_client.build_request.call_args
+        assert (
+            args[1]
+            == 'http://agent.example.com/api/my-tenant/extendedAgentCard'
+        )
+
+    @pytest.mark.asyncio
+    async def test_rest_get_task_prepend_empty_tenant(
+        self,
+        mock_httpx_client,
+        mock_agent_card,
+    ):
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        request = GetTaskRequest(tenant='', id='task-123')
+
+        # 1. Setup mocks
+        mock_httpx_client.build_request.return_value = MagicMock(
+            spec=httpx.Request
+        )
+        mock_httpx_client.send.return_value = AsyncMock(
+            spec=httpx.Response,
+            status_code=200,
+            json=MagicMock(return_value={}),
+        )
+
+        # 2. Call the method
+        await client.get_task(request=request)
+
+        # 3. Verify the URL
+        args, _ = mock_httpx_client.build_request.call_args
+        assert args[1] == 'http://agent.example.com/api/tasks/task-123'
+
+    @pytest.mark.parametrize(
+        'method_name, request_obj, expected_path',
+        [
+            (
+                'subscribe',
+                SubscribeToTaskRequest(tenant='my-tenant', id='task-123'),
+                '/my-tenant/tasks/task-123:subscribe',
+            ),
+            (
+                'send_message_streaming',
+                SendMessageRequest(
+                    tenant='my-tenant',
+                    message=new_text_message(text='hi'),
+                ),
+                '/my-tenant/message:stream',
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_rest_streaming_methods_prepend_tenant(  # noqa: PLR0913
+        self,
+        mock_aconnect_sse,
+        method_name,
+        request_obj,
+        expected_path,
+        mock_httpx_client,
+        mock_agent_card,
+    ):
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+
+        # 1. Get the method dynamically
+        method = getattr(client, method_name)
+
+        # 2. Setup mocks
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.raise_for_status.return_value = None
+        mock_response.aiter_text.return_value = async_iterable_from_list([])
+        mock_aconnect_sse.return_value.__aenter__.return_value = mock_response
+
+        # 3. Call the method
+        async for _ in method(request=request_obj):
+            pass
+
+        # 4. Verify the URL and method
+        mock_aconnect_sse.assert_called_once()
+        args, kwargs = mock_aconnect_sse.call_args
+        # method is 2nd positional argument
+        assert args[1] == 'POST'
+        if method_name == 'subscribe':
+            assert kwargs.get('json') is None
+        else:
+            assert kwargs.get('json') == json_format.MessageToDict(request_obj)
+
+        # url is 3rd positional argument in aconnect_sse(client, method, url, ...)
+        assert args[2] == f'http://agent.example.com/api{expected_path}'
+
+
+class TestRestTransportPathEncoding:
+    """Ids with reserved URL characters reach their own resource.
+
+    Runs a real request handler behind the REST routes, so a wrong path
+    reads or deletes the wrong resource.
+    """
+
+    @pytest_asyncio.fixture
+    async def transport(self) -> AsyncGenerator[RestTransport, None]:
+        task_store = InMemoryTaskStore()
+        await task_store.save(
+            Task(
+                id='t1',
+                context_id='c1',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            ),
+            ServerCallContext(),
+        )
+        agent_card = AgentCard(
+            capabilities=AgentCapabilities(push_notifications=True)
+        )
+        request_handler = DefaultRequestHandler(
+            None,
+            task_store,
+            agent_card,
+            push_config_store=InMemoryPushNotificationConfigStore(),
+        )
+        app = Starlette(
+            routes=create_rest_routes(request_handler=request_handler)
+        )
+        httpx_client = httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app),
+            headers={VERSION_HEADER: PROTOCOL_VERSION_CURRENT},
+        )
+        transport = RestTransport(httpx_client, agent_card, 'http://agent')
+        yield transport
+        await transport.close()
+
+    @pytest.mark.asyncio
+    async def test_delete_push_config_keeps_config_with_shared_prefix(
+        self, transport: RestTransport
+    ):
+        for config_id in ('alerts', 'alerts#ops'):
+            await transport.create_task_push_notification_config(
+                TaskPushNotificationConfig(
+                    task_id='t1',
+                    id=config_id,
+                    url='https://hooks.example.com/hook',
+                )
+            )
+
+        await transport.delete_task_push_notification_config(
+            DeleteTaskPushNotificationConfigRequest(
+                task_id='t1', id='alerts#ops'
+            )
+        )
+
+        response = await transport.list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id='t1')
+        )
+        assert [config.id for config in response.configs] == ['alerts']
+
+    @pytest.mark.asyncio
+    async def test_get_task_does_not_return_task_named_by_id_prefix(
+        self, transport: RestTransport
+    ):
+        with pytest.raises(TaskNotFoundError):
+            await transport.get_task(GetTaskRequest(id='t1?x'))
+
+
+class TestRestUnrecognizedResponseFields:
+    """Spec 5.7: unrecognized response fields are ignored (issue #1341)."""
+
+    @pytest.mark.asyncio
+    async def test_get_task_ignores_unrecognized_fields(
+        self, mock_httpx_client: AsyncMock, mock_agent_card: MagicMock
+    ):
+        """Unknown keys are skipped at every depth; known ones still parse."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        mock_httpx_client.build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json = MagicMock(
+            return_value={
+                'id': 'task-1',
+                'contextId': 'ctx-1',
+                'status': {
+                    'state': 'TASK_STATE_COMPLETED',
+                    'someNestedField': 'y',
+                },
+                'someNewField': 'x',
+            }
+        )
+        mock_httpx_client.send.return_value = mock_response
+
+        task = await client.get_task(GetTaskRequest(id='task-1'))
+
+        assert task.id == 'task-1'
+        assert task.context_id == 'ctx-1'
+        assert task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_send_message_streaming_ignores_unrecognized_fields(
+        self,
+        mock_sse_source: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+    ):
+        """This branch parses with Parse, not ParseDict, so it needs its own case."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        payload = {
+            'message': {
+                'messageId': 'r1',
+                'role': 'ROLE_AGENT',
+                'parts': [{'text': 'hello'}],
+            },
+            'someNewField': 'x',
+        }
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            [f'data: {json.dumps(payload)}\n\n']
+        )
+        mock_sse_source.return_value.__aenter__.return_value = mock_response
+
+        events = [
+            event
+            async for event in client.send_message_streaming(
+                SendMessageRequest(message=new_text_message(text='Hello'))
+            )
+        ]
+
+        assert len(events) == 1
+        assert events[0].message.message_id == 'r1'
+        assert events[0].message.parts[0].text == 'hello'
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize('body', [[], None])
+    async def test_get_task_rejects_body_that_is_not_an_object(
+        self,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+        body: object,
+    ):
+        """A 200 body that is not an object is not read as an empty Task."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        mock_httpx_client.build_request = MagicMock(
+            return_value=AsyncMock(spec=httpx.Request)
+        )
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json = MagicMock(return_value=body)
+        mock_httpx_client.send.return_value = mock_response
+
+        with pytest.raises(json_format.ParseError, match='JSON object'):
+            await client.get_task(GetTaskRequest(id='task-1'))
+
+
+_TASK_NOT_FOUND_BODY = {
+    'error': {
+        'code': 404,
+        'status': 'NOT_FOUND',
+        'message': 'Task t1 not found',
+        'details': [
+            {
+                '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                'reason': 'TASK_NOT_FOUND',
+                'domain': 'a2a-protocol.org',
+            }
+        ],
+    }
+}
+
+
+class TestRestStreamErrors:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        'sse_text',
+        [
+            f'event: error\ndata: {json.dumps(_TASK_NOT_FOUND_BODY)}\n\n',
+            f'data: {json.dumps(_TASK_NOT_FOUND_BODY)}\n\n',
+        ],
+        ids=['error_event', 'data_event'],
+    )
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_stream_error_raises_mapped_error(
+        self,
+        mock_sse_source: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+        sse_text: str,
+    ):
+        """An error body raises whether or not the event is named `error`."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            [sse_text]
+        )
+        mock_sse_source.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(TaskNotFoundError, match='Task t1 not found'):
+            async for _ in client.subscribe(SubscribeToTaskRequest(id='t1')):
+                pass
+
+    @pytest.mark.asyncio
+    @patch('a2a.client.transports.http_helpers._SSEEventSource')
+    async def test_stream_event_of_unknown_type_is_still_yielded(
+        self,
+        mock_sse_source: AsyncMock,
+        mock_httpx_client: AsyncMock,
+        mock_agent_card: MagicMock,
+    ):
+        """An event with no known payload and no error stays a lenient parse."""
+        client = RestTransport(
+            httpx_client=mock_httpx_client,
+            agent_card=mock_agent_card,
+            url='http://agent.example.com/api',
+        )
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.raise_for_status = MagicMock()
+        mock_response.headers = {'content-type': 'text/event-stream'}
+        mock_response.aiter_text.return_value = async_iterable_from_list(
+            [f'data: {json.dumps({"someNewEvent": {"id": "e1"}})}\n\n']
+        )
+        mock_sse_source.return_value.__aenter__.return_value = mock_response
+
+        events = [
+            event
+            async for event in client.subscribe(SubscribeToTaskRequest(id='t1'))
+        ]
+
+        assert len(events) == 1
+        assert events[0].WhichOneof('payload') is None
diff --git a/tests/client/transports/test_tenant_decorator.py b/tests/client/transports/test_tenant_decorator.py
new file mode 100644
index 000000000..354ca9769
--- /dev/null
+++ b/tests/client/transports/test_tenant_decorator.py
@@ -0,0 +1,129 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a.client.transports.base import ClientTransport
+from a2a.client.transports.tenant_decorator import TenantTransportDecorator
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    Message,
+    Part,
+    SendMessageRequest,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    TaskPushNotificationConfig,
+)
+
+
+@pytest.fixture
+def mock_transport() -> AsyncMock:
+    return AsyncMock(spec=ClientTransport)
+
+
+class TestTenantTransportDecorator:
+    @pytest.mark.asyncio
+    async def test_resolve_tenant_logic(
+        self, mock_transport: AsyncMock
+    ) -> None:
+        tenant_id = 'test-tenant'
+        decorator = TenantTransportDecorator(mock_transport, tenant_id)
+
+        # Case 1: Tenant already set on request
+        assert decorator._resolve_tenant('existing-tenant') == 'existing-tenant'
+
+        # Case 2: Tenant not set (empty string)
+        assert decorator._resolve_tenant('') == tenant_id
+
+    @pytest.mark.asyncio
+    async def test_resolve_tenant_logic_empty_tenant(
+        self, mock_transport: AsyncMock
+    ) -> None:
+        decorator = TenantTransportDecorator(mock_transport, '')
+
+        # Case 1: Tenant already set on request
+        assert decorator._resolve_tenant('existing-tenant') == 'existing-tenant'
+
+        # Case 2: Tenant not set (empty string)
+        assert decorator._resolve_tenant('') == ''
+
+    @pytest.mark.parametrize(
+        'method_name, request_obj',
+        [
+            (
+                'send_message',
+                SendMessageRequest(message=Message(parts=[Part(text='hello')])),
+            ),
+            (
+                'get_task',
+                GetTaskRequest(id='t1'),
+            ),
+            (
+                'list_tasks',
+                ListTasksRequest(),
+            ),
+            (
+                'cancel_task',
+                CancelTaskRequest(id='t1'),
+            ),
+            (
+                'create_task_push_notification_config',
+                TaskPushNotificationConfig(task_id='t1'),
+            ),
+            (
+                'get_task_push_notification_config',
+                GetTaskPushNotificationConfigRequest(task_id='t1', id='c1'),
+            ),
+            (
+                'list_task_push_notification_configs',
+                ListTaskPushNotificationConfigsRequest(task_id='t1'),
+            ),
+            (
+                'delete_task_push_notification_config',
+                DeleteTaskPushNotificationConfigRequest(task_id='t1', id='c1'),
+            ),
+            ('get_extended_agent_card', GetExtendedAgentCardRequest()),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_methods(
+        self, mock_transport: AsyncMock, method_name, request_obj
+    ) -> None:
+        """Test that tenant is set on the request for all methods."""
+        tenant_id = 'test-tenant'
+        decorator = TenantTransportDecorator(mock_transport, tenant_id)
+        mock_method = getattr(mock_transport, method_name)
+
+        await getattr(decorator, method_name)(request_obj)
+
+        mock_method.assert_called_once()
+        assert mock_transport.mock_calls[0][0] == method_name
+        assert request_obj.tenant == tenant_id
+
+    @pytest.mark.asyncio
+    async def test_streaming_methods(self, mock_transport: AsyncMock) -> None:
+        """Test that tenant is set on the request for streaming methods."""
+        tenant_id = 'test-tenant'
+        decorator = TenantTransportDecorator(mock_transport, tenant_id)
+
+        async def mock_stream(*args, **kwargs):
+            yield StreamResponse()
+
+        # Test subscribe
+        mock_transport.subscribe.return_value = mock_stream()
+        request_sub = SubscribeToTaskRequest(id='t1')
+        async for _ in decorator.subscribe(request_sub):
+            pass
+        assert request_sub.tenant == tenant_id
+
+        # Test send_message_streaming
+        mock_transport.send_message_streaming.return_value = mock_stream()
+        request_msg = SendMessageRequest()
+        async for _ in decorator.send_message_streaming(request_msg):
+            pass
+        assert request_msg.tenant == tenant_id
diff --git a/tests/compat/__init__.py b/tests/compat/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/compat/v0_3/__init__.py b/tests/compat/v0_3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/compat/v0_3/test_context_builders.py b/tests/compat/v0_3/test_context_builders.py
new file mode 100644
index 000000000..28e7e06f4
--- /dev/null
+++ b/tests/compat/v0_3/test_context_builders.py
@@ -0,0 +1,158 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import grpc
+
+from a2a.compat.v0_3.context_builders import (
+    V03GrpcServerCallContextBuilder,
+    V03ServerCallContextBuilder,
+)
+from a2a.compat.v0_3.extension_headers import LEGACY_HTTP_EXTENSION_HEADER
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.grpc_handler import (
+    DefaultGrpcServerCallContextBuilder,
+)
+from a2a.server.routes.common import DefaultServerCallContextBuilder
+from starlette.datastructures import Headers
+
+
+def _make_mock_request(headers=None):
+    request = MagicMock()
+    request.scope = {}
+    request.headers = Headers(headers or {})
+    return request
+
+
+def _make_mock_grpc_context(metadata: list[tuple[str, str]]) -> AsyncMock:
+    context = AsyncMock(spec=grpc.aio.ServicerContext)
+    context.invocation_metadata.return_value = grpc.aio.Metadata(*metadata)
+    return context
+
+
+class TestV03ServerCallContextBuilder:
+    def test_legacy_header_only(self):
+        request = _make_mock_request(
+            headers={LEGACY_HTTP_EXTENSION_HEADER: 'legacy-ext'}
+        )
+        builder = V03ServerCallContextBuilder(DefaultServerCallContextBuilder())
+
+        ctx = builder.build(request)
+
+        assert isinstance(ctx, ServerCallContext)
+        assert ctx.requested_extensions == {'legacy-ext'}
+
+    def test_spec_header_only(self):
+        request = _make_mock_request(
+            headers={HTTP_EXTENSION_HEADER: 'spec-ext'}
+        )
+        builder = V03ServerCallContextBuilder(DefaultServerCallContextBuilder())
+
+        ctx = builder.build(request)
+
+        assert ctx.requested_extensions == {'spec-ext'}
+
+    def test_both_headers_merged(self):
+        request = _make_mock_request(
+            headers={
+                HTTP_EXTENSION_HEADER: 'spec-ext',
+                LEGACY_HTTP_EXTENSION_HEADER: 'legacy-ext',
+            }
+        )
+        builder = V03ServerCallContextBuilder(DefaultServerCallContextBuilder())
+
+        ctx = builder.build(request)
+
+        assert ctx.requested_extensions == {'spec-ext', 'legacy-ext'}
+
+    def test_legacy_header_comma_separated(self):
+        request = _make_mock_request(
+            headers={LEGACY_HTTP_EXTENSION_HEADER: 'foo, bar'}
+        )
+        builder = V03ServerCallContextBuilder(DefaultServerCallContextBuilder())
+
+        ctx = builder.build(request)
+
+        assert ctx.requested_extensions == {'foo', 'bar'}
+
+    def test_no_extensions(self):
+        request = _make_mock_request()
+        builder = V03ServerCallContextBuilder(DefaultServerCallContextBuilder())
+
+        ctx = builder.build(request)
+
+        assert ctx.requested_extensions == set()
+
+
+class TestV03GrpcServerCallContextBuilder:
+    def test_legacy_metadata_only(self):
+        context = _make_mock_grpc_context(
+            [(LEGACY_HTTP_EXTENSION_HEADER.lower(), 'legacy-ext')]
+        )
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert isinstance(ctx, ServerCallContext)
+        assert ctx.requested_extensions == {'legacy-ext'}
+
+    def test_spec_metadata_only(self):
+        context = _make_mock_grpc_context(
+            [(HTTP_EXTENSION_HEADER.lower(), 'spec-ext')]
+        )
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert ctx.requested_extensions == {'spec-ext'}
+
+    def test_both_metadata_merged(self):
+        context = _make_mock_grpc_context(
+            [
+                (HTTP_EXTENSION_HEADER.lower(), 'spec-ext'),
+                (LEGACY_HTTP_EXTENSION_HEADER.lower(), 'legacy-ext'),
+            ]
+        )
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert ctx.requested_extensions == {'spec-ext', 'legacy-ext'}
+
+    def test_legacy_metadata_comma_separated(self):
+        context = _make_mock_grpc_context(
+            [(LEGACY_HTTP_EXTENSION_HEADER.lower(), 'foo, bar')]
+        )
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert ctx.requested_extensions == {'foo', 'bar'}
+
+    def test_no_extensions(self):
+        context = _make_mock_grpc_context([])
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert ctx.requested_extensions == set()
+
+    def test_no_metadata(self):
+        context = AsyncMock(spec=grpc.aio.ServicerContext)
+        context.invocation_metadata.return_value = None
+        builder = V03GrpcServerCallContextBuilder(
+            DefaultGrpcServerCallContextBuilder()
+        )
+
+        ctx = builder.build(context)
+
+        assert ctx.requested_extensions == set()
diff --git a/tests/compat/v0_3/test_conversions.py b/tests/compat/v0_3/test_conversions.py
new file mode 100644
index 000000000..8ef95528a
--- /dev/null
+++ b/tests/compat/v0_3/test_conversions.py
@@ -0,0 +1,2066 @@
+import base64
+import json
+
+from datetime import datetime
+
+import pytest
+
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.conversions import (
+    to_compat_agent_capabilities,
+    to_compat_agent_card,
+    to_compat_agent_card_signature,
+    to_compat_agent_extension,
+    to_compat_agent_interface,
+    to_compat_agent_provider,
+    to_compat_agent_skill,
+    to_compat_artifact,
+    to_compat_authentication_info,
+    to_compat_cancel_task_request,
+    to_compat_create_task_push_notification_config_request,
+    to_compat_delete_task_push_notification_config_request,
+    to_compat_get_extended_agent_card_request,
+    to_compat_get_task_push_notification_config_request,
+    to_compat_get_task_request,
+    to_compat_list_task_push_notification_config_request,
+    to_compat_list_task_push_notification_config_response,
+    to_compat_message,
+    to_compat_oauth_flows,
+    to_compat_part,
+    to_compat_push_notification_config,
+    to_compat_security_requirement,
+    to_compat_security_scheme,
+    to_compat_send_message_configuration,
+    to_compat_send_message_request,
+    to_compat_send_message_response,
+    to_compat_stream_response,
+    to_compat_subscribe_to_task_request,
+    to_compat_task,
+    to_compat_task_artifact_update_event,
+    to_compat_task_push_notification_config,
+    to_compat_task_status,
+    to_compat_task_status_update_event,
+    to_core_agent_capabilities,
+    to_core_agent_card,
+    to_core_agent_card_signature,
+    to_core_agent_extension,
+    to_core_agent_interface,
+    to_core_agent_provider,
+    to_core_agent_skill,
+    to_core_artifact,
+    to_core_authentication_info,
+    to_core_cancel_task_request,
+    to_core_create_task_push_notification_config_request,
+    to_core_delete_task_push_notification_config_request,
+    to_core_get_extended_agent_card_request,
+    to_core_get_task_push_notification_config_request,
+    to_core_get_task_request,
+    to_core_list_task_push_notification_config_request,
+    to_core_list_task_push_notification_config_response,
+    to_core_message,
+    to_core_oauth_flows,
+    to_core_part,
+    to_core_push_notification_config,
+    to_core_security_requirement,
+    to_core_security_scheme,
+    to_core_send_message_configuration,
+    to_core_send_message_request,
+    to_core_send_message_response,
+    to_core_stream_response,
+    to_core_subscribe_to_task_request,
+    to_core_task,
+    to_core_task_artifact_update_event,
+    to_core_task_push_notification_config,
+    to_core_task_status,
+    to_core_task_status_update_event,
+)
+from a2a.compat.v0_3.model_conversions import (
+    compat_push_notification_config_model_to_core,
+    compat_task_model_to_core,
+    core_to_compat_push_notification_config_model,
+    core_to_compat_task_model,
+)
+from a2a.types import a2a_pb2 as pb2_v10
+from a2a.utils.errors import VersionNotSupportedError
+from cryptography.fernet import Fernet
+from google.protobuf.json_format import ParseDict
+
+
+def test_text_part_conversion():
+    v03_part = types_v03.Part(
+        root=types_v03.TextPart(text='Hello, World!', metadata={'test': 'val'})
+    )
+    v10_expected = pb2_v10.Part(text='Hello, World!')
+    v10_expected.metadata.update({'test': 'val'})
+
+    v10_part = to_core_part(v03_part)
+    assert v10_part == v10_expected
+
+    v03_restored = to_compat_part(v10_part)
+    assert v03_restored == v03_part
+
+
+def test_data_part_conversion():
+    data = {'key': 'val', 'nested': {'a': 1}}
+    v03_part = types_v03.Part(root=types_v03.DataPart(data=data))
+    v10_expected = pb2_v10.Part()
+    ParseDict(data, v10_expected.data.struct_value)
+
+    v10_part = to_core_part(v03_part)
+    assert v10_part == v10_expected
+
+    v03_restored = to_compat_part(v10_part)
+    assert v03_restored == v03_part
+
+
+def test_data_part_conversion_primitive():
+    primitive_cases = [
+        'Primitive String',
+        42,
+        3.14,
+        True,
+        False,
+        ['a', 'b', 'c'],
+        [1, 2, 3],
+        None,
+    ]
+
+    for val in primitive_cases:
+        v10_expected = pb2_v10.Part()
+        ParseDict(val, v10_expected.data)
+
+        # Test v10 -> v03
+        v03_part = to_compat_part(v10_expected)
+        assert isinstance(v03_part.root, types_v03.DataPart)
+        assert v03_part.root.data == {'value': val}
+        assert v03_part.root.metadata['data_part_compat'] is True
+
+        # Test v03 -> v10
+        v10_restored = to_core_part(v03_part)
+        assert v10_restored == v10_expected
+
+
+def test_file_part_uri_conversion():
+    v03_file = types_v03.FileWithUri(
+        uri='http://example.com/file', mime_type='text/plain', name='file.txt'
+    )
+    v03_part = types_v03.Part(root=types_v03.FilePart(file=v03_file))
+    v10_expected = pb2_v10.Part(
+        url='http://example.com/file',
+        media_type='text/plain',
+        filename='file.txt',
+    )
+
+    v10_part = to_core_part(v03_part)
+    assert v10_part == v10_expected
+
+    v03_restored = to_compat_part(v10_part)
+    assert v03_restored == v03_part
+
+
+def test_file_part_bytes_conversion():
+    content = b'hello world'
+    b64 = base64.b64encode(content).decode('utf-8')
+    v03_file = types_v03.FileWithBytes(
+        bytes=b64, mime_type='application/octet-stream', name='file.bin'
+    )
+    v03_part = types_v03.Part(root=types_v03.FilePart(file=v03_file))
+    v10_expected = pb2_v10.Part(
+        raw=content, media_type='application/octet-stream', filename='file.bin'
+    )
+
+    v10_part = to_core_part(v03_part)
+    assert v10_part == v10_expected
+
+    v03_restored = to_compat_part(v10_part)
+    assert v03_restored == v03_part
+
+
+def test_message_conversion():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.user,
+        context_id='c1',
+        task_id='t1',
+        reference_task_ids=['rt1'],
+        metadata={'k': 'v'},
+        extensions=['ext1'],
+        parts=[types_v03.Part(root=types_v03.TextPart(text='hi'))],
+    )
+    v10_expected = pb2_v10.Message(
+        message_id='m1',
+        role=pb2_v10.Role.ROLE_USER,
+        context_id='c1',
+        task_id='t1',
+        reference_task_ids=['rt1'],
+        extensions=['ext1'],
+        parts=[pb2_v10.Part(text='hi')],
+    )
+    ParseDict({'k': 'v'}, v10_expected.metadata)
+
+    v10_msg = to_core_message(v03_msg)
+    assert v10_msg == v10_expected
+
+    v03_restored = to_compat_message(v10_msg)
+    assert v03_restored == v03_msg
+
+
+def test_message_conversion_minimal():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.agent,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='hi'))],
+    )
+    v10_expected = pb2_v10.Message(
+        message_id='m1',
+        role=pb2_v10.Role.ROLE_AGENT,
+        parts=[pb2_v10.Part(text='hi')],
+    )
+
+    v10_msg = to_core_message(v03_msg)
+    assert v10_msg == v10_expected
+
+    v03_restored = to_compat_message(v10_msg)
+    # v03 expects None for missing fields, conversions.py handles this correctly
+    assert v03_restored == v03_msg
+
+
+def test_task_status_conversion():
+    now_v03 = '2023-01-01T12:00:00Z'
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.agent,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='status'))],
+    )
+    v03_status = types_v03.TaskStatus(
+        state=types_v03.TaskState.working, message=v03_msg, timestamp=now_v03
+    )
+
+    v10_expected = pb2_v10.TaskStatus(
+        state=pb2_v10.TaskState.TASK_STATE_WORKING,
+        message=pb2_v10.Message(
+            message_id='m1',
+            role=pb2_v10.Role.ROLE_AGENT,
+            parts=[pb2_v10.Part(text='status')],
+        ),
+    )
+    v10_expected.timestamp.FromJsonString(now_v03)
+
+    v10_status = to_core_task_status(v03_status)
+    assert v10_status == v10_expected
+
+    v03_restored = to_compat_task_status(v10_status)
+    assert v03_restored == v03_status
+
+
+def test_task_status_conversion_special_states():
+    # input-required
+    s1 = types_v03.TaskStatus(state=types_v03.TaskState.input_required)
+    assert (
+        to_core_task_status(s1).state
+        == pb2_v10.TaskState.TASK_STATE_INPUT_REQUIRED
+    )
+    assert to_compat_task_status(to_core_task_status(s1)).state == s1.state
+
+    # auth-required
+    s2 = types_v03.TaskStatus(state=types_v03.TaskState.auth_required)
+    assert (
+        to_core_task_status(s2).state
+        == pb2_v10.TaskState.TASK_STATE_AUTH_REQUIRED
+    )
+    assert to_compat_task_status(to_core_task_status(s2)).state == s2.state
+
+    # unknown
+    s3 = types_v03.TaskStatus(state=types_v03.TaskState.unknown)
+    assert (
+        to_core_task_status(s3).state
+        == pb2_v10.TaskState.TASK_STATE_UNSPECIFIED
+    )
+    assert to_compat_task_status(to_core_task_status(s3)).state == s3.state
+
+
+def test_task_conversion():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.user,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='hi'))],
+    )
+    v03_status = types_v03.TaskStatus(state=types_v03.TaskState.submitted)
+    v03_art = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='data'))],
+    )
+
+    v03_task = types_v03.Task(
+        id='t1',
+        context_id='c1',
+        status=v03_status,
+        history=[v03_msg],
+        artifacts=[v03_art],
+        metadata={'m': 'v'},
+    )
+
+    v10_expected = pb2_v10.Task(
+        id='t1',
+        context_id='c1',
+        status=pb2_v10.TaskStatus(state=pb2_v10.TaskState.TASK_STATE_SUBMITTED),
+        history=[
+            pb2_v10.Message(
+                message_id='m1',
+                role=pb2_v10.Role.ROLE_USER,
+                parts=[pb2_v10.Part(text='hi')],
+            )
+        ],
+        artifacts=[
+            pb2_v10.Artifact(
+                artifact_id='a1', parts=[pb2_v10.Part(text='data')]
+            )
+        ],
+    )
+    ParseDict({'m': 'v'}, v10_expected.metadata)
+
+    v10_task = to_core_task(v03_task)
+    assert v10_task == v10_expected
+
+    v03_restored = to_compat_task(v10_task)
+    # v03 restored artifacts will have None for name/desc/etc
+    v03_expected_restored = types_v03.Task(
+        id='t1',
+        context_id='c1',
+        status=v03_status,
+        history=[v03_msg],
+        artifacts=[
+            types_v03.Artifact(
+                artifact_id='a1',
+                parts=[types_v03.Part(root=types_v03.TextPart(text='data'))],
+                name=None,
+                description=None,
+                metadata=None,
+                extensions=None,
+            )
+        ],
+        metadata={'m': 'v'},
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_task_conversion_minimal():
+    # Test v10 to v03 minimal
+    v10_min = pb2_v10.Task(id='tm', context_id='cm')
+    v03_expected_restored = types_v03.Task(
+        id='tm',
+        context_id='cm',
+        status=types_v03.TaskStatus(state=types_v03.TaskState.unknown),
+    )
+    v03_min_restored = to_compat_task(v10_min)
+    assert v03_min_restored == v03_expected_restored
+
+
+def test_authentication_info_conversion():
+    v03_auth = types_v03.PushNotificationAuthenticationInfo(
+        schemes=['Bearer'], credentials='token123'
+    )
+    v10_expected = pb2_v10.AuthenticationInfo(
+        scheme='Bearer', credentials='token123'
+    )
+    v10_auth = to_core_authentication_info(v03_auth)
+    assert v10_auth == v10_expected
+
+    v03_restored = to_compat_authentication_info(v10_auth)
+    assert v03_restored == v03_auth
+
+
+def test_authentication_info_conversion_minimal():
+    v03_auth = types_v03.PushNotificationAuthenticationInfo(schemes=[])
+    v10_expected = pb2_v10.AuthenticationInfo()
+
+    v10_auth = to_core_authentication_info(v03_auth)
+    assert v10_auth == v10_expected
+
+    v03_restored = to_compat_authentication_info(v10_auth)
+    v03_expected_restored = types_v03.PushNotificationAuthenticationInfo(
+        schemes=[], credentials=None
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_push_notification_config_conversion():
+    v03_auth = types_v03.PushNotificationAuthenticationInfo(schemes=['Basic'])
+    v03_config = types_v03.PushNotificationConfig(
+        id='c1',
+        url='http://test.com',
+        token='tok',  # noqa: S106
+        authentication=v03_auth,
+    )
+
+    v10_expected = pb2_v10.TaskPushNotificationConfig(
+        id='c1',
+        url='http://test.com',
+        token='tok',  # noqa: S106
+        authentication=pb2_v10.AuthenticationInfo(scheme='Basic'),
+    )
+
+    v10_config = to_core_push_notification_config(v03_config)
+    assert v10_config == v10_expected
+
+    v03_restored = to_compat_push_notification_config(v10_config)
+    assert v03_restored == v03_config
+
+
+def test_push_notification_config_conversion_minimal():
+    v03_config = types_v03.PushNotificationConfig(url='http://test.com')
+    v10_expected = pb2_v10.TaskPushNotificationConfig(url='http://test.com')
+
+    v10_config = to_core_push_notification_config(v03_config)
+    assert v10_config == v10_expected
+
+    v03_restored = to_compat_push_notification_config(v10_config)
+    v03_expected_restored = types_v03.PushNotificationConfig(
+        url='http://test.com', id=None, token=None, authentication=None
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_send_message_configuration_conversion():
+    v03_auth = types_v03.PushNotificationAuthenticationInfo(schemes=['Basic'])
+    v03_push = types_v03.PushNotificationConfig(
+        url='http://test', authentication=v03_auth
+    )
+
+    v03_config = types_v03.MessageSendConfiguration(
+        accepted_output_modes=['text/plain', 'application/json'],
+        history_length=10,
+        blocking=True,
+        push_notification_config=v03_push,
+    )
+
+    v10_expected = pb2_v10.SendMessageConfiguration(
+        accepted_output_modes=['text/plain', 'application/json'],
+        history_length=10,
+        task_push_notification_config=pb2_v10.TaskPushNotificationConfig(
+            url='http://test',
+            authentication=pb2_v10.AuthenticationInfo(scheme='Basic'),
+        ),
+    )
+
+    v10_config = to_core_send_message_configuration(v03_config)
+    assert v10_config == v10_expected
+
+    v03_restored = to_compat_send_message_configuration(v10_config)
+    assert v03_restored == v03_config
+
+
+def test_send_message_configuration_conversion_minimal():
+    v03_config = types_v03.MessageSendConfiguration()
+    v10_expected = pb2_v10.SendMessageConfiguration()
+
+    v10_config = to_core_send_message_configuration(v03_config)
+    assert v10_config == v10_expected
+    v03_restored = to_compat_send_message_configuration(v10_config)
+    v03_expected_restored = types_v03.MessageSendConfiguration(
+        accepted_output_modes=None,
+        history_length=None,
+        blocking=True,
+        push_notification_config=None,
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_send_message_configuration_conversion_history_length_zero():
+    v03_config = types_v03.MessageSendConfiguration(history_length=0)
+    v10_config = to_core_send_message_configuration(v03_config)
+    assert not v10_config.HasField('history_length')
+
+
+def test_artifact_conversion_full():
+    v03_artifact = types_v03.Artifact(
+        artifact_id='a1',
+        name='Test Art',
+        description='A test artifact',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='data'))],
+        metadata={'k': 'v'},
+        extensions=['ext1'],
+    )
+
+    v10_expected = pb2_v10.Artifact(
+        artifact_id='a1',
+        name='Test Art',
+        description='A test artifact',
+        parts=[pb2_v10.Part(text='data')],
+        extensions=['ext1'],
+    )
+    ParseDict({'k': 'v'}, v10_expected.metadata)
+
+    v10_art = to_core_artifact(v03_artifact)
+    assert v10_art == v10_expected
+
+    v03_restored = to_compat_artifact(v10_art)
+    assert v03_restored == v03_artifact
+
+
+def test_artifact_conversion_minimal():
+    v03_artifact = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='data'))],
+    )
+
+    v10_expected = pb2_v10.Artifact(
+        artifact_id='a1', parts=[pb2_v10.Part(text='data')]
+    )
+
+    v10_art = to_core_artifact(v03_artifact)
+    assert v10_art == v10_expected
+
+    v03_restored = to_compat_artifact(v10_art)
+    v03_expected_restored = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='data'))],
+        name=None,
+        description=None,
+        metadata=None,
+        extensions=None,
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_task_status_update_event_conversion():
+    v03_status = types_v03.TaskStatus(state=types_v03.TaskState.completed)
+    v03_event = types_v03.TaskStatusUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        status=v03_status,
+        metadata={'m': 'v'},
+        final=True,
+    )
+
+    v10_expected = pb2_v10.TaskStatusUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        status=pb2_v10.TaskStatus(state=pb2_v10.TaskState.TASK_STATE_COMPLETED),
+    )
+    ParseDict({'m': 'v'}, v10_expected.metadata)
+
+    v10_event = to_core_task_status_update_event(v03_event)
+    assert v10_event == v10_expected
+
+    v03_restored = to_compat_task_status_update_event(v10_event)
+    v03_expected_restored = types_v03.TaskStatusUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        status=v03_status,
+        metadata={'m': 'v'},
+        final=True,  # final is computed based on status.state
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_task_status_update_event_conversion_terminal_states():
+    # Test all terminal states result in final=True
+    terminal_states = [
+        (
+            pb2_v10.TaskState.TASK_STATE_COMPLETED,
+            types_v03.TaskState.completed,
+        ),
+        (pb2_v10.TaskState.TASK_STATE_CANCELED, types_v03.TaskState.canceled),
+        (pb2_v10.TaskState.TASK_STATE_FAILED, types_v03.TaskState.failed),
+        (pb2_v10.TaskState.TASK_STATE_REJECTED, types_v03.TaskState.rejected),
+    ]
+
+    for core_st, compat_st in terminal_states:
+        v10_event = pb2_v10.TaskStatusUpdateEvent(
+            status=pb2_v10.TaskStatus(state=core_st)
+        )
+        v03_restored = to_compat_task_status_update_event(v10_event)
+        assert v03_restored.final is True
+        assert v03_restored.status.state == compat_st
+
+    # Test non-terminal states result in final=False
+    non_terminal_states = [
+        (
+            pb2_v10.TaskState.TASK_STATE_SUBMITTED,
+            types_v03.TaskState.submitted,
+        ),
+        (pb2_v10.TaskState.TASK_STATE_WORKING, types_v03.TaskState.working),
+        (
+            pb2_v10.TaskState.TASK_STATE_INPUT_REQUIRED,
+            types_v03.TaskState.input_required,
+        ),
+        (
+            pb2_v10.TaskState.TASK_STATE_AUTH_REQUIRED,
+            types_v03.TaskState.auth_required,
+        ),
+        (
+            pb2_v10.TaskState.TASK_STATE_UNSPECIFIED,
+            types_v03.TaskState.unknown,
+        ),
+    ]
+
+    for core_st, compat_st in non_terminal_states:
+        v10_event = pb2_v10.TaskStatusUpdateEvent(
+            status=pb2_v10.TaskStatus(state=core_st)
+        )
+        v03_restored = to_compat_task_status_update_event(v10_event)
+        assert v03_restored.final is False
+        assert v03_restored.status.state == compat_st
+
+
+def test_task_status_update_event_conversion_minimal():
+    # v03 status is required but might be constructed empty internally
+    v10_event = pb2_v10.TaskStatusUpdateEvent(task_id='t1', context_id='c1')
+    v03_restored = to_compat_task_status_update_event(v10_event)
+    v03_expected = types_v03.TaskStatusUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        status=types_v03.TaskStatus(state=types_v03.TaskState.unknown),
+        final=False,
+    )
+    assert v03_restored == v03_expected
+
+
+def test_task_artifact_update_event_conversion():
+    v03_art = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='d'))],
+    )
+    v03_event = types_v03.TaskArtifactUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        artifact=v03_art,
+        append=True,
+        last_chunk=False,
+        metadata={'k': 'v'},
+    )
+
+    v10_expected = pb2_v10.TaskArtifactUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        artifact=pb2_v10.Artifact(
+            artifact_id='a1', parts=[pb2_v10.Part(text='d')]
+        ),
+        append=True,
+        last_chunk=False,
+    )
+    ParseDict({'k': 'v'}, v10_expected.metadata)
+
+    v10_event = to_core_task_artifact_update_event(v03_event)
+    assert v10_event == v10_expected
+
+    v03_restored = to_compat_task_artifact_update_event(v10_event)
+    assert v03_restored == v03_event
+
+
+def test_task_artifact_update_event_conversion_minimal():
+    v03_art = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='d'))],
+    )
+    v03_event = types_v03.TaskArtifactUpdateEvent(
+        task_id='t1', context_id='c1', artifact=v03_art
+    )
+
+    v10_expected = pb2_v10.TaskArtifactUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        artifact=pb2_v10.Artifact(
+            artifact_id='a1', parts=[pb2_v10.Part(text='d')]
+        ),
+    )
+
+    v10_event = to_core_task_artifact_update_event(v03_event)
+    assert v10_event == v10_expected
+
+    v03_restored = to_compat_task_artifact_update_event(v10_event)
+    v03_expected_restored = types_v03.TaskArtifactUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        artifact=v03_art,
+        append=False,  # primitive bools default to False
+        last_chunk=False,
+        metadata=None,
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_security_requirement_conversion():
+    v03_req = {'oauth': ['read', 'write'], 'apikey': []}
+
+    v10_expected = pb2_v10.SecurityRequirement()
+    sl_oauth = pb2_v10.StringList()
+    sl_oauth.list.extend(['read', 'write'])
+    sl_apikey = pb2_v10.StringList()
+    v10_expected.schemes['oauth'].CopyFrom(sl_oauth)
+    v10_expected.schemes['apikey'].CopyFrom(sl_apikey)
+
+    v10_req = to_core_security_requirement(v03_req)
+    assert v10_req == v10_expected
+
+    v03_restored = to_compat_security_requirement(v10_req)
+    assert v03_restored == v03_req
+
+
+def test_oauth_flows_conversion_auth_code():
+    v03_flows = types_v03.OAuthFlows(
+        authorization_code=types_v03.AuthorizationCodeOAuthFlow(
+            authorization_url='http://auth',
+            token_url='http://token',  # noqa: S106
+            scopes={'a': 'b'},
+            refresh_url='ref1',
+        )
+    )
+    v10_expected = pb2_v10.OAuthFlows(
+        authorization_code=pb2_v10.AuthorizationCodeOAuthFlow(
+            authorization_url='http://auth',
+            token_url='http://token',  # noqa: S106
+            scopes={'a': 'b'},
+            refresh_url='ref1',
+        )
+    )
+    v10_flows = to_core_oauth_flows(v03_flows)
+    assert v10_flows == v10_expected
+    v03_restored = to_compat_oauth_flows(v10_flows)
+    assert v03_restored == v03_flows
+
+
+def test_oauth_flows_conversion_client_credentials():
+    v03_flows = types_v03.OAuthFlows(
+        client_credentials=types_v03.ClientCredentialsOAuthFlow(
+            token_url='http://token2',  # noqa: S106
+            scopes={'c': 'd'},
+            refresh_url='ref2',
+        )
+    )
+    v10_expected = pb2_v10.OAuthFlows(
+        client_credentials=pb2_v10.ClientCredentialsOAuthFlow(
+            token_url='http://token2',  # noqa: S106
+            scopes={'c': 'd'},
+            refresh_url='ref2',
+        )
+    )
+    v10_flows = to_core_oauth_flows(v03_flows)
+    assert v10_flows == v10_expected
+    v03_restored = to_compat_oauth_flows(v10_flows)
+    assert v03_restored == v03_flows
+
+
+def test_oauth_flows_conversion_implicit():
+    v03_flows = types_v03.OAuthFlows(
+        implicit=types_v03.ImplicitOAuthFlow(
+            authorization_url='http://auth2',
+            scopes={'e': 'f'},
+            refresh_url='ref3',
+        )
+    )
+    v10_expected = pb2_v10.OAuthFlows(
+        implicit=pb2_v10.ImplicitOAuthFlow(
+            authorization_url='http://auth2',
+            scopes={'e': 'f'},
+            refresh_url='ref3',
+        )
+    )
+    v10_flows = to_core_oauth_flows(v03_flows)
+    assert v10_flows == v10_expected
+    v03_restored = to_compat_oauth_flows(v10_flows)
+    assert v03_restored == v03_flows
+
+
+def test_oauth_flows_conversion_password():
+    v03_flows = types_v03.OAuthFlows(
+        password=types_v03.PasswordOAuthFlow(
+            token_url='http://token3',  # noqa: S106
+            scopes={'g': 'h'},
+            refresh_url='ref4',
+        )
+    )
+    v10_expected = pb2_v10.OAuthFlows(
+        password=pb2_v10.PasswordOAuthFlow(
+            token_url='http://token3',  # noqa: S106
+            scopes={'g': 'h'},
+            refresh_url='ref4',
+        )
+    )
+    v10_flows = to_core_oauth_flows(v03_flows)
+    assert v10_flows == v10_expected
+    v03_restored = to_compat_oauth_flows(v10_flows)
+    assert v03_restored == v03_flows
+
+
+def test_security_scheme_apikey():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.APIKeySecurityScheme(
+            in_=types_v03.In.header, name='X-API-KEY', description='desc'
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        api_key_security_scheme=pb2_v10.APIKeySecurityScheme(
+            location='header', name='X-API-KEY', description='desc'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_http_auth():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.HTTPAuthSecurityScheme(
+            scheme='Bearer', bearer_format='JWT', description='desc'
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        http_auth_security_scheme=pb2_v10.HTTPAuthSecurityScheme(
+            scheme='Bearer', bearer_format='JWT', description='desc'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_oauth2():
+    v03_flows = types_v03.OAuthFlows(
+        authorization_code=types_v03.AuthorizationCodeOAuthFlow(
+            authorization_url='u',
+            token_url='t',  # noqa: S106
+            scopes={},
+        )
+    )
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.OAuth2SecurityScheme(
+            flows=v03_flows, oauth2_metadata_url='url', description='desc'
+        )
+    )
+
+    v10_expected = pb2_v10.SecurityScheme(
+        oauth2_security_scheme=pb2_v10.OAuth2SecurityScheme(
+            flows=pb2_v10.OAuthFlows(
+                authorization_code=pb2_v10.AuthorizationCodeOAuthFlow(
+                    authorization_url='u',
+                    token_url='t',  # noqa: S106
+                )
+            ),
+            oauth2_metadata_url='url',
+            description='desc',
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_oidc():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.OpenIdConnectSecurityScheme(
+            open_id_connect_url='url', description='desc'
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        open_id_connect_security_scheme=pb2_v10.OpenIdConnectSecurityScheme(
+            open_id_connect_url='url', description='desc'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_mtls():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.MutualTLSSecurityScheme(description='desc')
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        mtls_security_scheme=pb2_v10.MutualTlsSecurityScheme(description='desc')
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_oauth_flows_conversion_minimal():
+    v03_flows = types_v03.OAuthFlows(
+        authorization_code=types_v03.AuthorizationCodeOAuthFlow(
+            authorization_url='http://auth',
+            token_url='http://token',  # noqa: S106
+            scopes={'a': 'b'},
+        )  # no refresh_url
+    )
+    v10_expected = pb2_v10.OAuthFlows(
+        authorization_code=pb2_v10.AuthorizationCodeOAuthFlow(
+            authorization_url='http://auth',
+            token_url='http://token',  # noqa: S106
+            scopes={'a': 'b'},
+        )
+    )
+    v10_flows = to_core_oauth_flows(v03_flows)
+    assert v10_flows == v10_expected
+
+    v03_restored = to_compat_oauth_flows(v10_flows)
+    assert v03_restored == v03_flows
+
+
+def test_security_scheme_minimal():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.APIKeySecurityScheme(
+            in_=types_v03.In.header,
+            name='X-API-KEY',  # no description
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        api_key_security_scheme=pb2_v10.APIKeySecurityScheme(
+            location='header', name='X-API-KEY'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_http_auth_minimal():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.HTTPAuthSecurityScheme(
+            scheme='Bearer'  # no bearer_format, no description
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        http_auth_security_scheme=pb2_v10.HTTPAuthSecurityScheme(
+            scheme='Bearer'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_oauth2_minimal():
+    v03_flows = types_v03.OAuthFlows(
+        implicit=types_v03.ImplicitOAuthFlow(authorization_url='u', scopes={})
+    )
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.OAuth2SecurityScheme(
+            flows=v03_flows  # no oauth2_metadata_url, no description
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        oauth2_security_scheme=pb2_v10.OAuth2SecurityScheme(
+            flows=pb2_v10.OAuthFlows(
+                implicit=pb2_v10.ImplicitOAuthFlow(authorization_url='u')
+            )
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_oidc_minimal():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.OpenIdConnectSecurityScheme(
+            open_id_connect_url='url'  # no description
+        )
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        open_id_connect_security_scheme=pb2_v10.OpenIdConnectSecurityScheme(
+            open_id_connect_url='url'
+        )
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+
+
+def test_security_scheme_mtls_minimal():
+    v03_scheme = types_v03.SecurityScheme(
+        root=types_v03.MutualTLSSecurityScheme()
+    )
+    v10_expected = pb2_v10.SecurityScheme(
+        mtls_security_scheme=pb2_v10.MutualTlsSecurityScheme()
+    )
+    v10_scheme = to_core_security_scheme(v03_scheme)
+    assert v10_scheme == v10_expected
+    v03_restored = to_compat_security_scheme(v10_scheme)
+    assert v03_restored == v03_scheme
+    v10_scheme = pb2_v10.SecurityScheme()
+    with pytest.raises(ValueError, match='Unknown security scheme type'):
+        to_compat_security_scheme(v10_scheme)
+
+
+def test_agent_interface_conversion():
+    v03_int = types_v03.AgentInterface(url='http', transport='JSONRPC')
+    v10_expected = pb2_v10.AgentInterface(
+        url='http', protocol_binding='JSONRPC', protocol_version='0.3'
+    )
+    v10_int = to_core_agent_interface(v03_int)
+    assert v10_int == v10_expected
+    v03_restored = to_compat_agent_interface(v10_int)
+    assert v03_restored == v03_int
+
+
+def test_agent_provider_conversion():
+    v03_prov = types_v03.AgentProvider(url='u', organization='org')
+    v10_expected = pb2_v10.AgentProvider(url='u', organization='org')
+    v10_prov = to_core_agent_provider(v03_prov)
+    assert v10_prov == v10_expected
+    v03_restored = to_compat_agent_provider(v10_prov)
+    assert v03_restored == v03_prov
+
+
+def test_agent_extension_conversion():
+    v03_ext = types_v03.AgentExtension(
+        uri='u', description='d', required=True, params={'k': 'v'}
+    )
+    v10_expected = pb2_v10.AgentExtension(
+        uri='u', description='d', required=True
+    )
+    ParseDict({'k': 'v'}, v10_expected.params)
+    v10_ext = to_core_agent_extension(v03_ext)
+    assert v10_ext == v10_expected
+    v03_restored = to_compat_agent_extension(v10_ext)
+    assert v03_restored == v03_ext
+
+
+def test_agent_capabilities_conversion():
+    v03_ext = types_v03.AgentExtension(uri='u', required=False)
+    v03_cap = types_v03.AgentCapabilities(
+        streaming=True,
+        push_notifications=False,
+        extensions=[v03_ext],
+        state_transition_history=True,
+    )
+    v10_expected = pb2_v10.AgentCapabilities(
+        streaming=True,
+        push_notifications=False,
+        extensions=[pb2_v10.AgentExtension(uri='u', required=False)],
+    )
+    v10_cap = to_core_agent_capabilities(v03_cap)
+    assert v10_cap == v10_expected
+    v03_restored = to_compat_agent_capabilities(v10_cap)
+    v03_expected_restored = types_v03.AgentCapabilities(
+        streaming=True,
+        push_notifications=False,
+        extensions=[v03_ext],
+        state_transition_history=None,
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_agent_skill_conversion():
+    v03_skill = types_v03.AgentSkill(
+        id='s1',
+        name='n',
+        description='d',
+        tags=['t'],
+        examples=['e'],
+        input_modes=['i'],
+        output_modes=['o'],
+        security=[{'s': ['1']}],
+    )
+    v10_expected = pb2_v10.AgentSkill(
+        id='s1',
+        name='n',
+        description='d',
+        tags=['t'],
+        examples=['e'],
+        input_modes=['i'],
+        output_modes=['o'],
+    )
+    sl = pb2_v10.StringList()
+    sl.list.extend(['1'])
+    v10_expected.security_requirements.add().schemes['s'].CopyFrom(sl)
+
+    v10_skill = to_core_agent_skill(v03_skill)
+    assert v10_skill == v10_expected
+    v03_restored = to_compat_agent_skill(v10_skill)
+    assert v03_restored == v03_skill
+
+
+def test_agent_card_signature_conversion():
+    v03_sig = types_v03.AgentCardSignature(
+        protected='p', signature='s', header={'h': 'v'}
+    )
+    v10_expected = pb2_v10.AgentCardSignature(protected='p', signature='s')
+    ParseDict({'h': 'v'}, v10_expected.header)
+    v10_sig = to_core_agent_card_signature(v03_sig)
+    assert v10_sig == v10_expected
+    v03_restored = to_compat_agent_card_signature(v10_sig)
+    assert v03_restored == v03_sig
+
+
+def test_agent_card_conversion():
+    v03_int = types_v03.AgentInterface(url='u2', transport='HTTP')
+    v03_cap = types_v03.AgentCapabilities(streaming=True)
+    v03_skill = types_v03.AgentSkill(
+        id='s1',
+        name='sn',
+        description='sd',
+        tags=[],
+        input_modes=[],
+        output_modes=[],
+    )
+    v03_prov = types_v03.AgentProvider(url='pu', organization='po')
+
+    v03_card = types_v03.AgentCard(
+        name='n',
+        description='d',
+        version='v',
+        url='u1',
+        preferred_transport='JSONRPC',
+        protocol_version='0.3.0',
+        additional_interfaces=[v03_int],
+        provider=v03_prov,
+        documentation_url='du',
+        icon_url='iu',
+        capabilities=v03_cap,
+        supports_authenticated_extended_card=True,
+        security=[{'s': []}],
+        default_input_modes=['i'],
+        default_output_modes=['o'],
+        skills=[v03_skill],
+    )
+
+    v10_expected = pb2_v10.AgentCard(
+        name='n',
+        description='d',
+        version='v',
+        documentation_url='du',
+        icon_url='iu',
+        default_input_modes=['i'],
+        default_output_modes=['o'],
+    )
+    v10_expected.supported_interfaces.extend(
+        [
+            pb2_v10.AgentInterface(
+                url='u1', protocol_binding='JSONRPC', protocol_version='0.3.0'
+            ),
+            pb2_v10.AgentInterface(
+                url='u2', protocol_binding='HTTP', protocol_version='0.3'
+            ),
+        ]
+    )
+    v10_expected.provider.CopyFrom(
+        pb2_v10.AgentProvider(url='pu', organization='po')
+    )
+    v10_expected.capabilities.CopyFrom(
+        pb2_v10.AgentCapabilities(streaming=True, extended_agent_card=True)
+    )
+    v10_expected.security_requirements.add().schemes['s'].CopyFrom(
+        pb2_v10.StringList()
+    )
+    v10_expected.skills.add().CopyFrom(
+        pb2_v10.AgentSkill(id='s1', name='sn', description='sd')
+    )
+
+    v10_card = to_core_agent_card(v03_card)
+    assert v10_card == v10_expected
+
+    v03_restored = to_compat_agent_card(v10_card)
+    # We must explicitly set capabilities.state_transition_history to None in our original to match the restored
+    v03_card.capabilities.state_transition_history = None
+    # AgentSkill empty lists are converted to None during restoration
+    v03_card.skills[0].input_modes = None
+    v03_card.skills[0].output_modes = None
+    v03_card.skills[0].security = None
+    v03_card.skills[0].examples = None
+    assert v03_restored == v03_card
+
+
+def test_agent_card_conversion_minimal():
+    v03_cap = types_v03.AgentCapabilities()
+    v03_card = types_v03.AgentCard(
+        name='n',
+        description='d',
+        version='v',
+        url='u1',
+        preferred_transport='JSONRPC',
+        protocol_version='0.3.0',
+        capabilities=v03_cap,
+        default_input_modes=[],
+        default_output_modes=[],
+        skills=[],
+    )
+    v10_expected = pb2_v10.AgentCard(
+        name='n',
+        description='d',
+        version='v',
+        capabilities=pb2_v10.AgentCapabilities(),
+    )
+    v10_expected.supported_interfaces.extend(
+        [
+            pb2_v10.AgentInterface(
+                url='u1', protocol_binding='JSONRPC', protocol_version='0.3.0'
+            )
+        ]
+    )
+    v10_card = to_core_agent_card(v03_card)
+    assert v10_card == v10_expected
+
+    v03_restored = to_compat_agent_card(v10_card)
+    v03_card.capabilities.state_transition_history = None
+    assert v03_restored == v03_card
+
+
+def test_agent_skill_conversion_minimal():
+    v03_skill = types_v03.AgentSkill(
+        id='s1',
+        name='n',
+        description='d',
+        tags=[],
+        input_modes=[],
+        output_modes=[],
+    )
+    v10_expected = pb2_v10.AgentSkill(id='s1', name='n', description='d')
+    v10_skill = to_core_agent_skill(v03_skill)
+    assert v10_skill == v10_expected
+    v03_restored = to_compat_agent_skill(v10_skill)
+
+    # Restore sets missing optional lists to None usually. We adjust expected here
+    v03_expected_restored = types_v03.AgentSkill(
+        id='s1',
+        name='n',
+        description='d',
+        tags=[],
+        examples=None,
+        input_modes=None,
+        output_modes=None,
+        security=None,
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_agent_extension_conversion_minimal():
+    v03_ext = types_v03.AgentExtension(uri='u', required=False)
+    v10_expected = pb2_v10.AgentExtension(uri='u', required=False)
+    v10_ext = to_core_agent_extension(v03_ext)
+    assert v10_ext == v10_expected
+    v03_restored = to_compat_agent_extension(v10_ext)
+    v03_expected_restored = types_v03.AgentExtension(
+        uri='u', description=None, required=False, params=None
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_task_push_notification_config_conversion():
+    v03_auth = types_v03.PushNotificationAuthenticationInfo(schemes=['Basic'])
+    v03_cfg = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(
+            id='c1',
+            url='http://url',
+            token='tok',  # noqa: S106
+            authentication=v03_auth,
+        ),
+    )
+    v10_expected = pb2_v10.TaskPushNotificationConfig(
+        task_id='t1',
+        id='c1',
+        url='http://url',
+        token='tok',  # noqa: S106
+        authentication=pb2_v10.AuthenticationInfo(scheme='Basic'),
+    )
+    v10_cfg = to_core_task_push_notification_config(v03_cfg)
+    assert v10_cfg == v10_expected
+    v03_restored = to_compat_task_push_notification_config(v10_cfg)
+
+    v03_expected_restored = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(
+            id='c1',
+            url='http://url',
+            token='tok',  # noqa: S106
+            authentication=v03_auth,
+        ),
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_task_push_notification_config_conversion_minimal():
+    v03_cfg = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(
+            url='http://url'
+        ),
+    )
+    v10_expected = pb2_v10.TaskPushNotificationConfig(
+        task_id='t1', url='http://url'
+    )
+    v10_cfg = to_core_task_push_notification_config(v03_cfg)
+    assert v10_cfg == v10_expected
+    v03_restored = to_compat_task_push_notification_config(v10_cfg)
+    v03_expected_restored = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(
+            url='http://url'
+        ),
+    )
+    assert v03_restored == v03_expected_restored
+
+
+def test_send_message_request_conversion():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.user,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='Hi'))],
+    )
+    v03_cfg = types_v03.MessageSendConfiguration(history_length=5)
+    v03_req = types_v03.SendMessageRequest(
+        id='conv',
+        params=types_v03.MessageSendParams(
+            message=v03_msg, configuration=v03_cfg, metadata={'k': 'v'}
+        ),
+    )
+    v10_expected = pb2_v10.SendMessageRequest(
+        message=pb2_v10.Message(
+            message_id='m1',
+            role=pb2_v10.Role.ROLE_USER,
+            parts=[pb2_v10.Part(text='Hi')],
+        ),
+        configuration=pb2_v10.SendMessageConfiguration(history_length=5),
+    )
+    ParseDict({'k': 'v'}, v10_expected.metadata)
+
+    v10_req = to_core_send_message_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_send_message_request(v10_req, request_id='conv')
+    assert v03_restored.id == 'conv'
+    assert v03_restored.params.message.message_id == 'm1'
+    assert v03_restored.params.configuration.history_length == 5
+    assert v03_restored.params.metadata == {'k': 'v'}
+
+
+def test_get_task_request_conversion():
+    v03_req = types_v03.GetTaskRequest(
+        id='conv', params=types_v03.TaskQueryParams(id='t1', history_length=10)
+    )
+    v10_expected = pb2_v10.GetTaskRequest(id='t1', history_length=10)
+    v10_req = to_core_get_task_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_get_task_request(v10_req, request_id='conv')
+    assert v03_restored == v03_req
+
+
+def test_get_task_request_conversion_minimal():
+    v03_req = types_v03.GetTaskRequest(
+        id='conv', params=types_v03.TaskQueryParams(id='t1')
+    )
+    v10_expected = pb2_v10.GetTaskRequest(id='t1')
+    v10_req = to_core_get_task_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_get_task_request(v10_req, request_id='conv')
+    assert v03_restored == v03_req
+
+
+def test_get_task_request_conversion_history_length_zero():
+    v03_req = types_v03.GetTaskRequest(
+        id='conv', params=types_v03.TaskQueryParams(id='t1', history_length=0)
+    )
+    v10_req = to_core_get_task_request(v03_req)
+    assert not v10_req.HasField('history_length')
+
+
+def test_cancel_task_request_conversion():
+    v03_req = types_v03.CancelTaskRequest(
+        id='conv',
+        params=types_v03.TaskIdParams(id='t1', metadata={'reason': 'test'}),
+    )
+    v10_expected = pb2_v10.CancelTaskRequest(id='t1')
+    ParseDict({'reason': 'test'}, v10_expected.metadata)
+    v10_req = to_core_cancel_task_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_cancel_task_request(v10_req, request_id='conv')
+    assert v03_restored == v03_req
+
+
+def test_cancel_task_request_conversion_minimal():
+    v03_req = types_v03.CancelTaskRequest(
+        id='conv', params=types_v03.TaskIdParams(id='t1')
+    )
+    v10_expected = pb2_v10.CancelTaskRequest(id='t1')
+    v10_req = to_core_cancel_task_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_cancel_task_request(v10_req, request_id='conv')
+    assert v03_restored == v03_req
+
+
+def test_create_task_push_notification_config_request_conversion():
+    v03_cfg = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(url='u'),
+    )
+    v03_req = types_v03.SetTaskPushNotificationConfigRequest(
+        id='conv', params=v03_cfg
+    )
+    v10_expected = pb2_v10.TaskPushNotificationConfig(task_id='t1', url='u')
+    v10_req = to_core_create_task_push_notification_config_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_create_task_push_notification_config_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_stream_response_conversion():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.user,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='Hi'))],
+    )
+    v03_res = types_v03.SendStreamingMessageSuccessResponse(result=v03_msg)
+    v10_expected = pb2_v10.StreamResponse(
+        message=pb2_v10.Message(
+            message_id='m1',
+            role=pb2_v10.Role.ROLE_USER,
+            parts=[pb2_v10.Part(text='Hi')],
+        )
+    )
+    v10_res = to_core_stream_response(v03_res)
+    assert v10_res == v10_expected
+
+
+def test_get_task_push_notification_config_request_conversion():
+    v03_req = types_v03.GetTaskPushNotificationConfigRequest(
+        id='conv', params=types_v03.TaskIdParams(id='t1')
+    )
+    v10_expected = pb2_v10.GetTaskPushNotificationConfigRequest(task_id='t1')
+    v10_req = to_core_get_task_push_notification_config_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_get_task_push_notification_config_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_delete_task_push_notification_config_request_conversion():
+    v03_req = types_v03.DeleteTaskPushNotificationConfigRequest(
+        id='conv',
+        params=types_v03.DeleteTaskPushNotificationConfigParams(
+            id='t1', push_notification_config_id='p1'
+        ),
+    )
+    v10_expected = pb2_v10.DeleteTaskPushNotificationConfigRequest(
+        task_id='t1', id='p1'
+    )
+    v10_req = to_core_delete_task_push_notification_config_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_delete_task_push_notification_config_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_subscribe_to_task_request_conversion():
+    v03_req = types_v03.TaskResubscriptionRequest(
+        id='conv', params=types_v03.TaskIdParams(id='t1')
+    )
+    v10_expected = pb2_v10.SubscribeToTaskRequest(id='t1')
+    v10_req = to_core_subscribe_to_task_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_subscribe_to_task_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_list_task_push_notification_config_request_conversion():
+    v03_req = types_v03.ListTaskPushNotificationConfigRequest(
+        id='conv',
+        params=types_v03.ListTaskPushNotificationConfigParams(id='t1'),
+    )
+    v10_expected = pb2_v10.ListTaskPushNotificationConfigsRequest(task_id='t1')
+    v10_req = to_core_list_task_push_notification_config_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_list_task_push_notification_config_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_list_task_push_notification_config_response_conversion():
+    v03_cfg = types_v03.TaskPushNotificationConfig(
+        task_id='t1',
+        push_notification_config=types_v03.PushNotificationConfig(url='u'),
+    )
+    v03_res = types_v03.ListTaskPushNotificationConfigResponse(
+        root=types_v03.ListTaskPushNotificationConfigSuccessResponse(
+            id='conv', result=[v03_cfg]
+        )
+    )
+    v10_expected = pb2_v10.ListTaskPushNotificationConfigsResponse(
+        configs=[pb2_v10.TaskPushNotificationConfig(task_id='t1', url='u')]
+    )
+    v10_res = to_core_list_task_push_notification_config_response(v03_res)
+    assert v10_res == v10_expected
+    v03_restored = to_compat_list_task_push_notification_config_response(
+        v10_res, request_id='conv'
+    )
+    assert v03_restored == v03_res
+
+
+def test_send_message_response_conversion():
+    v03_task = types_v03.Task(
+        id='t1',
+        context_id='c1',
+        status=types_v03.TaskStatus(state=types_v03.TaskState.unknown),
+    )
+    v03_res = types_v03.SendMessageResponse(
+        root=types_v03.SendMessageSuccessResponse(id='conv', result=v03_task)
+    )
+    v10_expected = pb2_v10.SendMessageResponse(
+        task=pb2_v10.Task(
+            id='t1',
+            context_id='c1',
+            status=pb2_v10.TaskStatus(
+                state=pb2_v10.TaskState.TASK_STATE_UNSPECIFIED
+            ),
+        )
+    )
+    v10_res = to_core_send_message_response(v03_res)
+    assert v10_res == v10_expected
+    v03_restored = to_compat_send_message_response(v10_res, request_id='conv')
+    assert v03_restored == v03_res
+
+
+def test_stream_response_conversion_with_id():
+    v10_res = pb2_v10.StreamResponse(
+        message=pb2_v10.Message(
+            message_id='m1',
+            role=pb2_v10.Role.ROLE_USER,
+            parts=[pb2_v10.Part(text='Hi')],
+        )
+    )
+    v03_res = to_compat_stream_response(v10_res, request_id='req123')
+    assert v03_res.id == 'req123'
+    assert v03_res.result.message_id == 'm1'
+
+
+def test_get_extended_agent_card_request_conversion():
+    v03_req = types_v03.GetAuthenticatedExtendedCardRequest(id='conv')
+    v10_expected = pb2_v10.GetExtendedAgentCardRequest()
+    v10_req = to_core_get_extended_agent_card_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_get_extended_agent_card_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_get_task_push_notification_config_request_conversion_full_params():
+    v03_req = types_v03.GetTaskPushNotificationConfigRequest(
+        id='conv',
+        params=types_v03.GetTaskPushNotificationConfigParams(
+            id='t1', push_notification_config_id='p1'
+        ),
+    )
+    v10_expected = pb2_v10.GetTaskPushNotificationConfigRequest(
+        task_id='t1', id='p1'
+    )
+    v10_req = to_core_get_task_push_notification_config_request(v03_req)
+    assert v10_req == v10_expected
+    v03_restored = to_compat_get_task_push_notification_config_request(
+        v10_req, request_id='conv'
+    )
+    assert v03_restored == v03_req
+
+
+def test_send_message_response_conversion_message():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.agent,
+        parts=[types_v03.Part(root=types_v03.TextPart(text='Hi'))],
+    )
+    v03_res = types_v03.SendMessageResponse(
+        root=types_v03.SendMessageSuccessResponse(id='conv', result=v03_msg)
+    )
+    v10_expected = pb2_v10.SendMessageResponse(
+        message=pb2_v10.Message(
+            message_id='m1',
+            role=pb2_v10.Role.ROLE_AGENT,
+            parts=[pb2_v10.Part(text='Hi')],
+        )
+    )
+    v10_res = to_core_send_message_response(v03_res)
+    assert v10_res == v10_expected
+    v03_restored = to_compat_send_message_response(v10_res, request_id='conv')
+    assert v03_restored == v03_res
+
+
+def test_stream_response_conversion_status_update():
+    v03_status_event = types_v03.TaskStatusUpdateEvent(
+        task_id='t1',
+        context_id='c1',
+        status=types_v03.TaskStatus(state=types_v03.TaskState.working),
+        final=False,
+    )
+    v03_res = types_v03.SendStreamingMessageSuccessResponse(
+        id='conv', result=v03_status_event
+    )
+    v10_expected = pb2_v10.StreamResponse(
+        status_update=pb2_v10.TaskStatusUpdateEvent(
+            task_id='t1',
+            context_id='c1',
+            status=pb2_v10.TaskStatus(
+                state=pb2_v10.TaskState.TASK_STATE_WORKING
+            ),
+        )
+    )
+    v10_res = to_core_stream_response(v03_res)
+    assert v10_res == v10_expected
+    v03_restored = to_compat_stream_response(v10_res, request_id='conv')
+    assert v03_restored == v03_res
+
+
+def test_stream_response_conversion_artifact_update():
+    v03_art = types_v03.Artifact(
+        artifact_id='a1',
+        parts=[types_v03.Part(root=types_v03.TextPart(text='d'))],
+    )
+    v03_artifact_event = types_v03.TaskArtifactUpdateEvent(
+        task_id='t1', context_id='c1', artifact=v03_art
+    )
+    v03_res = types_v03.SendStreamingMessageSuccessResponse(
+        id='conv', result=v03_artifact_event
+    )
+    v10_expected = pb2_v10.StreamResponse(
+        artifact_update=pb2_v10.TaskArtifactUpdateEvent(
+            task_id='t1',
+            context_id='c1',
+            artifact=pb2_v10.Artifact(
+                artifact_id='a1', parts=[pb2_v10.Part(text='d')]
+            ),
+        )
+    )
+    v10_res = to_core_stream_response(v03_res)
+    assert v10_res == v10_expected
+    v03_restored = to_compat_stream_response(v10_res, request_id='conv')
+    # restored artifact update has default append=False, last_chunk=False
+    v03_expected = types_v03.SendStreamingMessageSuccessResponse(
+        id='conv',
+        result=types_v03.TaskArtifactUpdateEvent(
+            task_id='t1',
+            context_id='c1',
+            artifact=v03_art,
+            append=False,
+            last_chunk=False,
+        ),
+    )
+    assert v03_restored == v03_expected
+
+
+def test_oauth_flows_conversion_priority():
+    # v03 allows multiple, v10 allows one (oneof)
+    v03_flows = types_v03.OAuthFlows(
+        authorization_code=types_v03.AuthorizationCodeOAuthFlow(
+            authorization_url='http://auth',
+            token_url='http://token',  # noqa: S106
+            scopes={'a': 'b'},
+        ),
+        client_credentials=types_v03.ClientCredentialsOAuthFlow(
+            token_url='http://token2',  # noqa: S106
+            scopes={'c': 'd'},
+        ),
+    )
+
+    core_flows = to_core_oauth_flows(v03_flows)
+    # The last one set wins in proto oneof. In conversions.py order is:
+    # authorization_code, client_credentials, implicit, password.
+    # So client_credentials should win over authorization_code.
+    assert core_flows.WhichOneof('flow') == 'client_credentials'
+    assert core_flows.client_credentials.token_url == 'http://token2'  # noqa: S105
+
+
+def test_to_core_part_data_part_with_metadata_not_compat():
+    v03_part = types_v03.Part(
+        root=types_v03.DataPart(
+            data={'foo': 'bar'}, metadata={'other_key': 'val'}
+        )
+    )
+    core_part = to_core_part(v03_part)
+    assert core_part.data.struct_value['foo'] == 'bar'
+    assert core_part.metadata['other_key'] == 'val'
+
+
+def test_to_core_part_file_with_bytes_minimal():
+    v03_part = types_v03.Part(
+        root=types_v03.FilePart(
+            file=types_v03.FileWithBytes(bytes='YmFzZTY0')
+            # missing mime_type and name
+        )
+    )
+    core_part = to_core_part(v03_part)
+    assert core_part.raw == b'base64'
+    assert not core_part.media_type
+    assert not core_part.filename
+
+
+def test_to_core_part_file_with_uri_minimal():
+    v03_part = types_v03.Part(
+        root=types_v03.FilePart(
+            file=types_v03.FileWithUri(uri='http://test')
+            # missing mime_type and name
+        )
+    )
+    core_part = to_core_part(v03_part)
+    assert core_part.url == 'http://test'
+    assert not core_part.media_type
+    assert not core_part.filename
+
+
+def test_to_compat_part_unknown_content():
+    core_part = pb2_v10.Part()
+    # It has no content set (WhichOneof returns None)
+    with pytest.raises(ValueError, match='Unknown part content type: None'):
+        to_compat_part(core_part)
+
+
+def test_to_core_message_unspecified_role():
+    v03_msg = types_v03.Message(
+        message_id='m1',
+        role=types_v03.Role.user,  # Required by pydantic model, bypass to None for test
+        parts=[],
+    )
+    v03_msg.role = None
+    core_msg = to_core_message(v03_msg)
+    assert core_msg.role == pb2_v10.Role.ROLE_UNSPECIFIED
+
+
+def test_to_core_task_status_missing_state():
+    v03_status = types_v03.TaskStatus.model_construct(state=None)
+    core_status = to_core_task_status(v03_status)
+    assert core_status.state == pb2_v10.TaskState.TASK_STATE_UNSPECIFIED
+
+
+def test_to_core_task_status_update_event_missing_status():
+    v03_event = types_v03.TaskStatusUpdateEvent.model_construct(
+        task_id='t1', context_id='c1', status=None, final=False
+    )
+    core_event = to_core_task_status_update_event(v03_event)
+    assert not core_event.HasField('status')
+
+
+def test_to_core_task_artifact_update_event_missing_artifact():
+    v03_event = types_v03.TaskArtifactUpdateEvent.model_construct(
+        task_id='t1', context_id='c1', artifact=None
+    )
+    core_event = to_core_task_artifact_update_event(v03_event)
+    assert not core_event.HasField('artifact')
+
+
+def test_to_core_agent_card_with_security_and_signatures():
+    v03_card = types_v03.AgentCard.model_construct(
+        name='test',
+        description='test',
+        version='1.0',
+        url='http://url',
+        capabilities=types_v03.AgentCapabilities(),
+        security_schemes={
+            'scheme1': types_v03.SecurityScheme(
+                root=types_v03.MutualTLSSecurityScheme.model_construct(
+                    description='mtls'
+                )
+            )
+        },
+        signatures=[
+            types_v03.AgentCardSignature.model_construct(
+                protected='prot', signature='sig'
+            )
+        ],
+        default_input_modes=[],
+        default_output_modes=[],
+        skills=[],
+    )
+    core_card = to_core_agent_card(v03_card)
+    assert 'scheme1' in core_card.security_schemes
+    assert len(core_card.signatures) == 1
+    assert core_card.signatures[0].signature == 'sig'
+
+
+def test_to_core_send_message_request_no_configuration():
+    v03_req = types_v03.SendMessageRequest.model_construct(
+        id=1,
+        params=types_v03.MessageSendParams.model_construct(
+            message=None, configuration=None, metadata=None
+        ),
+    )
+    core_req = to_core_send_message_request(v03_req)
+    # Blocking by default (return_immediately=False)
+    assert core_req.configuration.return_immediately is False
+    assert not core_req.HasField('message')
+
+
+def test_to_core_list_task_push_notification_config_response_error():
+    v03_res = types_v03.ListTaskPushNotificationConfigResponse(
+        root=types_v03.JSONRPCErrorResponse(
+            id=1, error=types_v03.JSONRPCError(code=-32000, message='Error')
+        )
+    )
+    core_res = to_core_list_task_push_notification_config_response(v03_res)
+    assert len(core_res.configs) == 0
+
+
+def test_to_core_send_message_response_error():
+    v03_res = types_v03.SendMessageResponse(
+        root=types_v03.JSONRPCErrorResponse(
+            id=1, error=types_v03.JSONRPCError(code=-32000, message='Error')
+        )
+    )
+    core_res = to_core_send_message_response(v03_res)
+    assert not core_res.HasField('message')
+    assert not core_res.HasField('task')
+
+
+def test_stream_response_task_variant():
+    v03_task = types_v03.Task(
+        id='t1',
+        context_id='c1',
+        status=types_v03.TaskStatus(state=types_v03.TaskState.working),
+    )
+    v03_res = types_v03.SendStreamingMessageSuccessResponse(
+        id=1, result=v03_task
+    )
+    core_res = to_core_stream_response(v03_res)
+    assert core_res.HasField('task')
+    assert core_res.task.id == 't1'
+
+    v03_restored = to_compat_stream_response(core_res, request_id=1)
+    assert isinstance(v03_restored.result, types_v03.Task)
+    assert v03_restored.result.id == 't1'
+
+
+def test_to_compat_stream_response_unknown():
+    core_res = pb2_v10.StreamResponse()
+    with pytest.raises(
+        ValueError, match='Unknown stream response event type: None'
+    ):
+        to_compat_stream_response(core_res)
+
+
+def test_to_core_part_file_part_with_metadata():
+    v03_part = types_v03.Part(
+        root=types_v03.FilePart(
+            file=types_v03.FileWithBytes(
+                bytes='YmFzZTY0', mime_type='test/test', name='test.txt'
+            ),
+            metadata={'test': 'val'},
+        )
+    )
+    core_part = to_core_part(v03_part)
+    assert core_part.metadata['test'] == 'val'
+
+
+def test_to_core_part_file_part_invalid_file_type():
+    v03_part = types_v03.Part.model_construct(
+        root=types_v03.FilePart.model_construct(
+            file=None,  # Not FileWithBytes or FileWithUri
+            metadata=None,
+        )
+    )
+    core_part = to_core_part(v03_part)
+    # Should fall through to the end and return an empty part
+    assert not core_part.HasField('raw')
+
+
+def test_to_core_task_missing_status():
+    v03_task = types_v03.Task.model_construct(
+        id='t1', context_id='c1', status=None
+    )
+    core_task = to_core_task(v03_task)
+    assert not core_task.HasField('status')
+
+
+def test_to_core_security_scheme_unknown_type():
+    v03_scheme = types_v03.SecurityScheme.model_construct(root=None)
+    core_scheme = to_core_security_scheme(v03_scheme)
+    # Returns an empty SecurityScheme
+    assert core_scheme.WhichOneof('scheme') is None
+
+
+def test_to_core_agent_extension_minimal():
+    v03_ext = types_v03.AgentExtension.model_construct(
+        uri='', description=None, required=None, params=None
+    )
+    core_ext = to_core_agent_extension(v03_ext)
+    assert core_ext.uri == ''
+
+
+def test_to_core_task_push_notification_config_missing_config():
+    v03_config = types_v03.TaskPushNotificationConfig.model_construct(
+        task_id='t1', push_notification_config=None
+    )
+    core_config = to_core_task_push_notification_config(v03_config)
+    assert not core_config.url
+
+
+def test_to_core_create_task_push_notification_config_request_missing_config():
+    v03_req = types_v03.SetTaskPushNotificationConfigRequest.model_construct(
+        id=1,
+        params=types_v03.TaskPushNotificationConfig.model_construct(
+            task_id='t1', push_notification_config=None
+        ),
+    )
+    core_req = to_core_create_task_push_notification_config_request(v03_req)
+    assert not core_req.url
+
+
+def test_to_core_list_task_push_notification_config_request_missing_id():
+    v03_req = types_v03.ListTaskPushNotificationConfigRequest.model_construct(
+        id=1,
+        params=types_v03.ListTaskPushNotificationConfigParams.model_construct(
+            id=''
+        ),
+    )
+    core_req = to_core_list_task_push_notification_config_request(v03_req)
+    assert core_req.task_id == ''
+
+
+def test_to_core_stream_response_unknown_result():
+    v03_res = types_v03.SendStreamingMessageSuccessResponse.model_construct(
+        id=1, result=None
+    )
+    core_res = to_core_stream_response(v03_res)
+    assert core_res.WhichOneof('payload') is None
+
+
+def test_to_core_part_unknown_part():
+    # If the root of the part is somehow none of TextPart, DataPart, or FilePart,
+    # it should just return an empty core Part.
+    v03_part = types_v03.Part.model_construct(root=None)
+    core_part = to_core_part(v03_part)
+    assert not core_part.HasField('text')
+    assert not core_part.HasField('data')
+    assert not core_part.HasField('raw')
+    assert not core_part.HasField('url')
+
+
+def test_task_db_conversion():
+    v10_task = pb2_v10.Task(
+        id='task-123',
+        context_id='ctx-456',
+        status=pb2_v10.TaskStatus(
+            state=pb2_v10.TaskState.TASK_STATE_WORKING,
+        ),
+        metadata={'m1': 'v1'},
+    )
+    owner = 'owner-789'
+
+    # Test Core -> Model
+    model = core_to_compat_task_model(v10_task, owner)
+    assert model.id == 'task-123'
+    assert model.context_id == 'ctx-456'
+    assert model.owner == owner
+    assert model.protocol_version == '0.3'
+    assert model.status['state'] == 'working'
+    assert model.task_metadata == {'m1': 'v1'}
+
+    # Test Model -> Core
+    v10_restored = compat_task_model_to_core(model)
+    assert v10_restored.id == v10_task.id
+    assert v10_restored.context_id == v10_task.context_id
+    assert v10_restored.status.state == v10_task.status.state
+    assert v10_restored.metadata == v10_task.metadata
+
+
+def test_task_db_conversion_sets_last_updated():
+    """The status timestamp becomes last_updated, as in the v1.0 model."""
+    v10_task = pb2_v10.Task(id='task-123', context_id='ctx-456')
+    v10_task.status.timestamp.FromJsonString('2026-10-01T12:00:00Z')
+
+    model = core_to_compat_task_model(v10_task, 'owner-789')
+    assert model.last_updated == datetime(2026, 10, 1, 12, 0)
+
+    v10_task.status.ClearField('timestamp')
+    assert core_to_compat_task_model(v10_task, 'owner-789').last_updated is None
+
+
+def test_push_notification_config_db_conversion():
+    task_id = 'task-123'
+    v10_config = pb2_v10.TaskPushNotificationConfig(
+        id='pnc-1',
+        url='https://example.com/push',
+        token='secret-token',
+    )
+    owner = 'owner-789'
+
+    # Test Core -> Model (No encryption)
+    model = core_to_compat_push_notification_config_model(
+        task_id, v10_config, owner
+    )
+    assert model.task_id == task_id
+    assert model.config_id == 'pnc-1'
+    assert model.owner == owner
+    assert model.protocol_version == '0.3'
+
+    import json
+
+    data = json.loads(model.config_data.decode('utf-8'))
+    assert data['url'] == 'https://example.com/push'
+    assert data['token'] == 'secret-token'
+
+    # Test Model -> Core
+    v10_restored = compat_push_notification_config_model_to_core(
+        model.config_data.decode('utf-8'), task_id
+    )
+    assert v10_restored.id == v10_config.id
+    assert v10_restored.url == v10_config.url
+    assert v10_restored.token == v10_config.token
+
+
+def test_push_notification_config_persistence_conversion_with_encryption():
+    task_id = 'task-123'
+    v10_config = pb2_v10.TaskPushNotificationConfig(
+        id='pnc-1',
+        url='https://example.com/push',
+        token='secret-token',
+    )
+    owner = 'owner-789'
+    key = Fernet.generate_key()
+    fernet = Fernet(key)
+
+    # Test Core -> Model (With encryption)
+    model = core_to_compat_push_notification_config_model(
+        task_id, v10_config, owner, fernet=fernet
+    )
+    assert (
+        model.config_data != v10_config.SerializeToString()
+    )  # Should be encrypted
+
+    # Decrypt and verify
+    decrypted_data = fernet.decrypt(model.config_data)
+
+    data = json.loads(decrypted_data.decode('utf-8'))
+    assert data['url'] == 'https://example.com/push'
+    assert data['token'] == 'secret-token'
+
+    # Test Model -> Core
+    v10_restored = compat_push_notification_config_model_to_core(
+        decrypted_data.decode('utf-8'), task_id
+    )
+    assert v10_restored.id == v10_config.id
+    assert v10_restored.url == v10_config.url
+    assert v10_restored.token == v10_config.token
+
+
+def test_to_compat_agent_card_unsupported_version():
+    card = pb2_v10.AgentCard(
+        name='Modern Agent',
+        description='Only supports 1.0',
+        version='1.0.0',
+        supported_interfaces=[
+            pb2_v10.AgentInterface(
+                url='http://grpc.v10.com',
+                protocol_binding='GRPC',
+                protocol_version='1.0.0',
+            ),
+        ],
+        capabilities=pb2_v10.AgentCapabilities(),
+    )
+    with pytest.raises(
+        VersionNotSupportedError,
+        match='AgentCard must have at least one interface with compatible protocol version.',
+    ):
+        to_compat_agent_card(card)
diff --git a/tests/compat/v0_3/test_extension_headers.py b/tests/compat/v0_3/test_extension_headers.py
new file mode 100644
index 000000000..d5abbdfcc
--- /dev/null
+++ b/tests/compat/v0_3/test_extension_headers.py
@@ -0,0 +1,39 @@
+from a2a.compat.v0_3.extension_headers import (
+    LEGACY_HTTP_EXTENSION_HEADER,
+    add_legacy_extension_header,
+)
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+
+
+def test_legacy_header_constant_value():
+    assert LEGACY_HTTP_EXTENSION_HEADER == 'X-A2A-Extensions'
+
+
+def test_mirrors_spec_header_under_legacy_name():
+    params = {HTTP_EXTENSION_HEADER: 'foo,bar'}
+
+    add_legacy_extension_header(params)
+
+    assert params == {
+        HTTP_EXTENSION_HEADER: 'foo,bar',
+        LEGACY_HTTP_EXTENSION_HEADER: 'foo,bar',
+    }
+
+
+def test_no_op_when_spec_header_absent():
+    params = {'Other': 'value'}
+
+    add_legacy_extension_header(params)
+
+    assert params == {'Other': 'value'}
+
+
+def test_does_not_overwrite_existing_legacy_header():
+    params = {
+        HTTP_EXTENSION_HEADER: 'spec',
+        LEGACY_HTTP_EXTENSION_HEADER: 'legacy-original',
+    }
+
+    add_legacy_extension_header(params)
+
+    assert params[LEGACY_HTTP_EXTENSION_HEADER] == 'legacy-original'
diff --git a/tests/compat/v0_3/test_grpc_handler.py b/tests/compat/v0_3/test_grpc_handler.py
new file mode 100644
index 000000000..813f15242
--- /dev/null
+++ b/tests/compat/v0_3/test_grpc_handler.py
@@ -0,0 +1,537 @@
+from unittest.mock import ANY, AsyncMock, MagicMock
+
+import grpc
+import grpc.aio
+import pytest
+
+from a2a.compat.v0_3 import (
+    a2a_v0_3_pb2,
+    grpc_handler as compat_grpc_handler,
+)
+from a2a.server.request_handlers import RequestHandler
+from a2a.types import a2a_pb2
+from a2a.utils.errors import InvalidParamsError
+
+
+@pytest.fixture
+def mock_request_handler() -> AsyncMock:
+    return AsyncMock(spec=RequestHandler)
+
+
+@pytest.fixture
+def mock_grpc_context() -> AsyncMock:
+    context = AsyncMock(spec=grpc.aio.ServicerContext)
+    context.abort = AsyncMock()
+    context.set_trailing_metadata = MagicMock()
+    context.invocation_metadata = MagicMock(return_value=grpc.aio.Metadata())
+    return context
+
+
+@pytest.fixture
+def sample_agent_card() -> a2a_pb2.AgentCard:
+    return a2a_pb2.AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        version='1.0.0',
+        capabilities=a2a_pb2.AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            extended_agent_card=True,
+        ),
+        supported_interfaces=[
+            a2a_pb2.AgentInterface(
+                url='http://jsonrpc.v03.com',
+                protocol_binding='JSONRPC',
+                protocol_version='0.3',
+            ),
+        ],
+    )
+
+
+@pytest.fixture
+def handler(
+    mock_request_handler: AsyncMock, sample_agent_card: a2a_pb2.AgentCard
+) -> compat_grpc_handler.CompatGrpcHandler:
+    return compat_grpc_handler.CompatGrpcHandler(
+        request_handler=mock_request_handler,
+    )
+
+
+@pytest.mark.asyncio
+async def test_send_message_success_task(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.SendMessageRequest(
+        request=a2a_v0_3_pb2.Message(
+            message_id='msg-1', role=a2a_v0_3_pb2.Role.ROLE_USER
+        )
+    )
+    mock_request_handler.on_message_send.return_value = a2a_pb2.Task(
+        id='task-1', context_id='ctx-1'
+    )
+
+    response = await handler.SendMessage(request, mock_grpc_context)
+
+    expected_req = a2a_pb2.SendMessageRequest(
+        message=a2a_pb2.Message(
+            message_id='msg-1', role=a2a_pb2.Role.ROLE_USER
+        ),
+    )
+    mock_request_handler.on_message_send.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.SendMessageResponse(
+        task=a2a_v0_3_pb2.Task(
+            id='task-1', context_id='ctx-1', status=a2a_v0_3_pb2.TaskStatus()
+        )
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_send_message_success_message(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.SendMessageRequest(
+        request=a2a_v0_3_pb2.Message(
+            message_id='msg-1', role=a2a_v0_3_pb2.Role.ROLE_USER
+        )
+    )
+    mock_request_handler.on_message_send.return_value = a2a_pb2.Message(
+        message_id='msg-2', role=a2a_pb2.Role.ROLE_AGENT
+    )
+
+    response = await handler.SendMessage(request, mock_grpc_context)
+
+    expected_req = a2a_pb2.SendMessageRequest(
+        message=a2a_pb2.Message(
+            message_id='msg-1', role=a2a_pb2.Role.ROLE_USER
+        ),
+    )
+    mock_request_handler.on_message_send.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.SendMessageResponse(
+        msg=a2a_v0_3_pb2.Message(
+            message_id='msg-2', role=a2a_v0_3_pb2.Role.ROLE_AGENT
+        )
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_send_streaming_message_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    async def mock_stream(*args, **kwargs):
+        yield a2a_pb2.Task(id='task-1', context_id='ctx-1')
+        yield a2a_pb2.Message(message_id='msg-2', role=a2a_pb2.Role.ROLE_AGENT)
+        yield a2a_pb2.TaskStatusUpdateEvent(
+            task_id='task-1',
+            context_id='ctx-1',
+            status=a2a_pb2.TaskStatus(
+                state=a2a_pb2.TaskState.TASK_STATE_WORKING
+            ),
+        )
+        yield a2a_pb2.TaskArtifactUpdateEvent(
+            task_id='task-1',
+            context_id='ctx-1',
+            artifact=a2a_pb2.Artifact(artifact_id='art-1'),
+        )
+
+    mock_request_handler.on_message_send_stream.side_effect = mock_stream
+    request = a2a_v0_3_pb2.SendMessageRequest(
+        request=a2a_v0_3_pb2.Message(
+            message_id='msg-1', role=a2a_v0_3_pb2.Role.ROLE_USER
+        )
+    )
+
+    responses = []
+    async for res in handler.SendStreamingMessage(request, mock_grpc_context):
+        responses.append(res)
+
+    expected_req = a2a_pb2.SendMessageRequest(
+        message=a2a_pb2.Message(
+            message_id='msg-1', role=a2a_pb2.Role.ROLE_USER
+        ),
+    )
+    mock_request_handler.on_message_send_stream.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_responses = [
+        a2a_v0_3_pb2.StreamResponse(
+            task=a2a_v0_3_pb2.Task(
+                id='task-1',
+                context_id='ctx-1',
+                status=a2a_v0_3_pb2.TaskStatus(),
+            )
+        ),
+        a2a_v0_3_pb2.StreamResponse(
+            msg=a2a_v0_3_pb2.Message(
+                message_id='msg-2', role=a2a_v0_3_pb2.Role.ROLE_AGENT
+            )
+        ),
+        a2a_v0_3_pb2.StreamResponse(
+            status_update=a2a_v0_3_pb2.TaskStatusUpdateEvent(
+                task_id='task-1',
+                context_id='ctx-1',
+                status=a2a_v0_3_pb2.TaskStatus(
+                    state=a2a_v0_3_pb2.TaskState.TASK_STATE_WORKING
+                ),
+            )
+        ),
+        a2a_v0_3_pb2.StreamResponse(
+            artifact_update=a2a_v0_3_pb2.TaskArtifactUpdateEvent(
+                task_id='task-1',
+                context_id='ctx-1',
+                artifact=a2a_v0_3_pb2.Artifact(artifact_id='art-1'),
+            )
+        ),
+    ]
+    assert responses == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_get_task_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.GetTaskRequest(name='tasks/task-1')
+    mock_request_handler.on_get_task.return_value = a2a_pb2.Task(
+        id='task-1', context_id='ctx-1'
+    )
+
+    response = await handler.GetTask(request, mock_grpc_context)
+
+    expected_req = a2a_pb2.GetTaskRequest(id='task-1')
+    mock_request_handler.on_get_task.assert_called_once_with(expected_req, ANY)
+
+    expected_res = a2a_v0_3_pb2.Task(
+        id='task-1', context_id='ctx-1', status=a2a_v0_3_pb2.TaskStatus()
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_get_task_not_found(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.GetTaskRequest(name='tasks/task-1')
+    mock_request_handler.on_get_task.return_value = None
+
+    await handler.GetTask(request, mock_grpc_context)
+
+    expected_req = a2a_pb2.GetTaskRequest(id='task-1')
+    mock_request_handler.on_get_task.assert_called_once_with(expected_req, ANY)
+    mock_grpc_context.abort.assert_called()
+    assert mock_grpc_context.abort.call_args[0][0] == grpc.StatusCode.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_cancel_task_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.CancelTaskRequest(name='tasks/task-1')
+    mock_request_handler.on_cancel_task.return_value = a2a_pb2.Task(
+        id='task-1', context_id='ctx-1'
+    )
+
+    response = await handler.CancelTask(request, mock_grpc_context)
+
+    expected_req = a2a_pb2.CancelTaskRequest(id='task-1')
+    mock_request_handler.on_cancel_task.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.Task(
+        id='task-1', context_id='ctx-1', status=a2a_v0_3_pb2.TaskStatus()
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_task_subscription_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    async def mock_stream(*args, **kwargs):
+        yield a2a_pb2.TaskStatusUpdateEvent(
+            task_id='task-1',
+            context_id='ctx-1',
+            status=a2a_pb2.TaskStatus(
+                state=a2a_pb2.TaskState.TASK_STATE_WORKING
+            ),
+        )
+
+    mock_request_handler.on_subscribe_to_task.side_effect = mock_stream
+    request = a2a_v0_3_pb2.TaskSubscriptionRequest(name='tasks/task-1')
+
+    responses = []
+    async for res in handler.TaskSubscription(request, mock_grpc_context):
+        responses.append(res)
+
+    expected_req = a2a_pb2.SubscribeToTaskRequest(id='task-1')
+    mock_request_handler.on_subscribe_to_task.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_responses = [
+        a2a_v0_3_pb2.StreamResponse(
+            status_update=a2a_v0_3_pb2.TaskStatusUpdateEvent(
+                task_id='task-1',
+                context_id='ctx-1',
+                status=a2a_v0_3_pb2.TaskStatus(
+                    state=a2a_v0_3_pb2.TaskState.TASK_STATE_WORKING
+                ),
+            )
+        )
+    ]
+    assert responses == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_create_push_config_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.CreateTaskPushNotificationConfigRequest(
+        parent='tasks/task-1',
+        config=a2a_v0_3_pb2.TaskPushNotificationConfig(
+            push_notification_config=a2a_v0_3_pb2.PushNotificationConfig(
+                url='http://example.com'
+            )
+        ),
+    )
+    mock_request_handler.on_create_task_push_notification_config.return_value = a2a_pb2.TaskPushNotificationConfig(
+        task_id='task-1',
+        url='http://example.com',
+        id='cfg-1',
+    )
+
+    response = await handler.CreateTaskPushNotificationConfig(
+        request, mock_grpc_context
+    )
+
+    expected_req = a2a_pb2.TaskPushNotificationConfig(
+        task_id='task-1',
+        url='http://example.com',
+    )
+    mock_request_handler.on_create_task_push_notification_config.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.TaskPushNotificationConfig(
+        name='tasks/task-1/pushNotificationConfigs/cfg-1',
+        push_notification_config=a2a_v0_3_pb2.PushNotificationConfig(
+            url='http://example.com', id='cfg-1'
+        ),
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_get_push_config_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.GetTaskPushNotificationConfigRequest(
+        name='tasks/task-1/pushNotificationConfigs/cfg-1'
+    )
+    mock_request_handler.on_get_task_push_notification_config.return_value = (
+        a2a_pb2.TaskPushNotificationConfig(
+            task_id='task-1',
+            url='http://example.com',
+            id='cfg-1',
+        )
+    )
+
+    response = await handler.GetTaskPushNotificationConfig(
+        request, mock_grpc_context
+    )
+
+    expected_req = a2a_pb2.GetTaskPushNotificationConfigRequest(
+        task_id='task-1', id='cfg-1'
+    )
+    mock_request_handler.on_get_task_push_notification_config.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.TaskPushNotificationConfig(
+        name='tasks/task-1/pushNotificationConfigs/cfg-1',
+        push_notification_config=a2a_v0_3_pb2.PushNotificationConfig(
+            url='http://example.com', id='cfg-1'
+        ),
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_list_push_config_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.ListTaskPushNotificationConfigRequest(
+        parent='tasks/task-1'
+    )
+    mock_request_handler.on_list_task_push_notification_configs.return_value = (
+        a2a_pb2.ListTaskPushNotificationConfigsResponse(
+            configs=[
+                a2a_pb2.TaskPushNotificationConfig(
+                    task_id='task-1', url='http://example.com', id='cfg-1'
+                )
+            ]
+        )
+    )
+
+    response = await handler.ListTaskPushNotificationConfig(
+        request, mock_grpc_context
+    )
+
+    expected_req = a2a_pb2.ListTaskPushNotificationConfigsRequest(
+        task_id='task-1'
+    )
+    mock_request_handler.on_list_task_push_notification_configs.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    expected_res = a2a_v0_3_pb2.ListTaskPushNotificationConfigResponse(
+        configs=[
+            a2a_v0_3_pb2.TaskPushNotificationConfig(
+                name='tasks/task-1/pushNotificationConfigs/cfg-1',
+                push_notification_config=a2a_v0_3_pb2.PushNotificationConfig(
+                    url='http://example.com', id='cfg-1'
+                ),
+            )
+        ]
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_get_agent_card_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+    sample_agent_card: a2a_pb2.AgentCard,
+) -> None:
+    request = a2a_v0_3_pb2.GetAgentCardRequest()
+    mock_request_handler.on_get_extended_agent_card.return_value = (
+        sample_agent_card
+    )
+
+    response = await handler.GetAgentCard(request, mock_grpc_context)
+
+    expected_res = a2a_v0_3_pb2.AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        url='http://jsonrpc.v03.com',
+        version='1.0.0',
+        protocol_version='0.3',
+        supports_authenticated_extended_card=True,
+        preferred_transport='JSONRPC',
+        capabilities=a2a_v0_3_pb2.AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+        ),
+    )
+    assert response == expected_res
+
+
+@pytest.mark.asyncio
+async def test_delete_push_config_success(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    request = a2a_v0_3_pb2.DeleteTaskPushNotificationConfigRequest(
+        name='tasks/task-1/pushNotificationConfigs/cfg-1'
+    )
+    mock_request_handler.on_delete_task_push_notification_config.return_value = None
+
+    from google.protobuf import empty_pb2
+
+    response = await handler.DeleteTaskPushNotificationConfig(
+        request, mock_grpc_context
+    )
+
+    expected_req = a2a_pb2.DeleteTaskPushNotificationConfigRequest(
+        task_id='task-1', id='cfg-1'
+    )
+    mock_request_handler.on_delete_task_push_notification_config.assert_called_once_with(
+        expected_req, ANY
+    )
+
+    assert isinstance(response, empty_pb2.Empty)
+
+
+@pytest.mark.asyncio
+async def test_extract_task_id_invalid(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+):
+    with pytest.raises(InvalidParamsError):
+        handler._extract_task_id('invalid-name')
+
+
+@pytest.mark.asyncio
+async def test_extract_task_and_config_id_invalid(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+):
+    with pytest.raises(InvalidParamsError):
+        handler._extract_task_and_config_id('invalid-name')
+
+
+@pytest.mark.asyncio
+async def test_get_agent_card_with_device_code_oauth_flow(
+    handler: compat_grpc_handler.CompatGrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+    sample_agent_card: a2a_pb2.AgentCard,
+) -> None:
+    """A v1.0 device code flow, which v0.3 lacks, is sent with no flows."""
+    sample_agent_card.security_schemes['device'].CopyFrom(
+        a2a_pb2.SecurityScheme(
+            oauth2_security_scheme=a2a_pb2.OAuth2SecurityScheme(
+                description='Device code',
+                flows=a2a_pb2.OAuthFlows(
+                    device_code=a2a_pb2.DeviceCodeOAuthFlow(
+                        device_authorization_url='https://auth.example.com/device',
+                        token_url='https://auth.example.com/token',
+                        scopes={'read': 'Read access'},
+                    )
+                ),
+            )
+        )
+    )
+    mock_request_handler.on_get_extended_agent_card.return_value = (
+        sample_agent_card
+    )
+
+    response = await handler.GetAgentCard(
+        a2a_v0_3_pb2.GetAgentCardRequest(), mock_grpc_context
+    )
+
+    mock_grpc_context.abort.assert_not_called()
+    assert response.security_schemes['device'] == a2a_v0_3_pb2.SecurityScheme(
+        oauth2_security_scheme=a2a_v0_3_pb2.OAuth2SecurityScheme(
+            description='Device code',
+            flows=a2a_v0_3_pb2.OAuthFlows(),
+        )
+    )
diff --git a/tests/compat/v0_3/test_grpc_transport.py b/tests/compat/v0_3/test_grpc_transport.py
new file mode 100644
index 000000000..c9a3c665f
--- /dev/null
+++ b/tests/compat/v0_3/test_grpc_transport.py
@@ -0,0 +1,71 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from a2a.client.client import ClientCallContext
+from a2a.client.optionals import Channel
+from a2a.compat.v0_3 import a2a_v0_3_pb2
+from a2a.compat.v0_3.grpc_transport import CompatGrpcTransport
+from a2a.types.a2a_pb2 import (
+    Message,
+    Role,
+    SendMessageRequest,
+    SendMessageResponse,
+)
+
+
+@pytest.mark.asyncio
+async def test_compat_grpc_transport_send_message_response_msg_parsing():
+    mock_channel = AsyncMock(spec=Channel)
+    transport = CompatGrpcTransport(channel=mock_channel, agent_card=None)
+
+    mock_stub = MagicMock()
+
+    expected_resp = a2a_v0_3_pb2.SendMessageResponse(
+        msg=a2a_v0_3_pb2.Message(
+            message_id='msg-123', role=a2a_v0_3_pb2.Role.ROLE_AGENT
+        )
+    )
+
+    mock_stub.SendMessage = AsyncMock(return_value=expected_resp)
+    transport.stub = mock_stub
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+
+    assert isinstance(response, SendMessageResponse)
+    assert response.HasField('message')
+    assert response.message.message_id == 'msg-123'
+
+    sent = mock_stub.SendMessage.call_args.args[0]
+    assert not sent.HasField('configuration')
+
+
+def test_compat_grpc_transport_mirrors_extension_metadata():
+    """Compat gRPC client must also emit the legacy x-a2a-extensions metadata
+    so that v0.3 servers (which only know that name) understand the request."""
+    transport = CompatGrpcTransport(
+        channel=AsyncMock(spec=Channel), agent_card=None
+    )
+    context = ClientCallContext(
+        service_parameters={'A2A-Extensions': 'foo,bar'}
+    )
+
+    metadata = dict(transport._get_grpc_metadata(context))
+
+    assert metadata['a2a-extensions'] == 'foo,bar'
+    assert metadata['x-a2a-extensions'] == 'foo,bar'
+
+
+def test_compat_grpc_transport_no_extension_metadata():
+    transport = CompatGrpcTransport(
+        channel=AsyncMock(spec=Channel), agent_card=None
+    )
+
+    metadata = dict(transport._get_grpc_metadata(None))
+
+    assert 'a2a-extensions' not in metadata
+    assert 'x-a2a-extensions' not in metadata
diff --git a/tests/compat/v0_3/test_jsonrpc_app_compat.py b/tests/compat/v0_3/test_jsonrpc_app_compat.py
new file mode 100644
index 000000000..5a9227d20
--- /dev/null
+++ b/tests/compat/v0_3/test_jsonrpc_app_compat.py
@@ -0,0 +1,294 @@
+import json
+import logging
+
+from collections.abc import AsyncIterator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from a2a.compat.v0_3 import jsonrpc_adapter
+from a2a.compat.v0_3.jsonrpc_adapter import JSONRPC03Adapter
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import create_jsonrpc_routes
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    Message as Message10,
+    Part as Part10,
+    Role as Role10,
+    Task as Task10,
+    TaskState as TaskState10,
+    TaskStatus as TaskStatus10,
+)
+from a2a.utils.errors import (
+    A2AError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from starlette.applications import Starlette
+from starlette.testclient import TestClient
+
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.asyncio
+async def test_shutdown_grace_period_is_passed_to_event_source_response(
+    mock_handler: AsyncMock,
+) -> None:
+    async def stream_generator() -> AsyncIterator[MagicMock]:
+        yield MagicMock()
+
+    adapter = JSONRPC03Adapter(
+        http_handler=mock_handler,
+        shutdown_grace_period=30.0,
+    )
+    adapter.handler.on_message_send_stream = MagicMock(
+        return_value=stream_generator()
+    )
+    request_obj = MagicMock(method='message/stream')
+
+    with patch.object(
+        jsonrpc_adapter, 'create_event_source_response'
+    ) as response_class:
+        await adapter._process_streaming_request(
+            request_id='1',
+            request_obj=request_obj,
+            context=ServerCallContext(),
+        )
+
+    response_class.assert_called_once()
+    assert response_class.call_args.kwargs['shutdown_grace_period'] == 30.0
+
+
+@pytest.fixture
+def mock_handler():
+    handler = AsyncMock(spec=RequestHandler)
+    handler.on_message_send.return_value = Message10(
+        message_id='test',
+        role=Role10.ROLE_AGENT,
+        parts=[Part10(text='response message')],
+    )
+    handler.on_get_task.return_value = Task10(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=TaskStatus10(
+            state=TaskState10.TASK_STATE_COMPLETED,
+        ),
+    )
+    return handler
+
+
+@pytest.fixture
+def agent_card():
+    card = AgentCard(
+        name='TestAgent',
+        description='Test Description',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=False, push_notifications=True, extended_agent_card=True
+        ),
+    )
+    interface = card.supported_interfaces.add()
+    interface.url = 'http://mockurl.com'
+    interface.protocol_binding = 'jsonrpc'
+    interface.protocol_version = '0.3'
+    return card
+
+
+@pytest.fixture
+def test_app(mock_handler, agent_card):
+    mock_handler._agent_card = agent_card
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_handler,
+        enable_v0_3_compat=True,
+        rpc_url='/',
+    )
+    return Starlette(routes=jsonrpc_routes)
+
+
+@pytest.fixture
+def client(test_app):
+    return TestClient(test_app)
+
+
+def test_send_message_v03_compat(
+    client: TestClient, mock_handler: AsyncMock
+) -> None:
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '1',
+        'method': 'message/send',
+        'params': {
+            'message': {
+                'messageId': 'req',
+                'role': 'user',
+                'parts': [{'text': 'hello'}],
+            }
+        },
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['jsonrpc'] == '2.0'
+    assert data['id'] == '1'
+    assert 'result' in data
+    assert data['result']['messageId'] == 'test'
+    assert data['result']['parts'][0]['text'] == 'response message'
+
+
+def test_get_task_v03_compat(
+    client: TestClient, mock_handler: AsyncMock
+) -> None:
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '2',
+        'method': 'tasks/get',
+        'params': {'id': 'test_task_id'},
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['jsonrpc'] == '2.0'
+    assert data['id'] == '2'
+    assert 'result' in data
+    assert data['result']['id'] == 'test_task_id'
+    assert data['result']['status']['state'] == 'completed'
+
+
+def test_get_extended_agent_card_v03_compat(
+    client: TestClient, mock_handler: AsyncMock, agent_card: AgentCard
+) -> None:
+    """Test that the v0.3 method name 'agent/getAuthenticatedExtendedCard' is correctly routed."""
+    mock_handler.on_get_extended_agent_card.return_value = agent_card
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '3',
+        'method': 'agent/getAuthenticatedExtendedCard',
+        'params': {},
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['jsonrpc'] == '2.0'
+    assert data['id'] == '3'
+    assert 'result' in data
+    # The result should be a v0.3 AgentCard
+    assert 'supportsAuthenticatedExtendedCard' in data['result']
+
+
+def test_get_task_not_found_v03_compat(
+    client: TestClient, mock_handler: AsyncMock
+) -> None:
+    mock_handler.on_get_task.return_value = None
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '4',
+        'method': 'tasks/get',
+        'params': {'id': 'missing_task_id'},
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['id'] == '4'
+    assert data['error']['code'] == -32001
+    assert data['error']['message'] == 'Task not found'
+
+
+def test_invalid_params_v03_compat(
+    client: TestClient, mock_handler: AsyncMock
+) -> None:
+    # The JSON-RPC envelope is valid but the params are not: a v0.3 Message
+    # requires `parts`, so validating params fails and must return -32602.
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '7',
+        'method': 'message/send',
+        'params': {'message': {'messageId': 'req', 'role': 'user'}},
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['id'] == '7'
+    assert data['error']['code'] == -32602
+    mock_handler.on_message_send.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ('error', 'expected_code'),
+    [
+        (TaskNotFoundError(), -32001),
+        (TaskNotCancelableError(), -32002),
+        (UnsupportedOperationError(), -32004),
+    ],
+)
+def test_cancel_task_v03_compat_maps_a2a_error_codes(
+    client: TestClient,
+    mock_handler: AsyncMock,
+    error: A2AError,
+    expected_code: int,
+) -> None:
+    mock_handler.on_cancel_task.side_effect = error
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '5',
+        'method': 'tasks/cancel',
+        'params': {'id': 'test_task_id'},
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data['id'] == '5'
+    assert data['error']['code'] == expected_code
+    assert data['error']['message'] == error.message
+
+
+def test_message_stream_v03_compat_maps_a2a_error_code(
+    client: TestClient, mock_handler: AsyncMock
+) -> None:
+    async def failing_stream(
+        *args: object, **kwargs: object
+    ) -> AsyncIterator[MagicMock]:
+        raise TaskNotFoundError
+        yield MagicMock()
+
+    mock_handler.on_message_send_stream = failing_stream
+    request_payload = {
+        'jsonrpc': '2.0',
+        'id': '6',
+        'method': 'message/stream',
+        'params': {
+            'message': {
+                'messageId': 'req',
+                'role': 'user',
+                'parts': [{'text': 'hello'}],
+            }
+        },
+    }
+
+    response = client.post('/', json=request_payload)
+    assert response.status_code == 200
+    events = [
+        json.loads(line.removeprefix('data:'))
+        for line in response.text.splitlines()
+        if line.startswith('data:')
+    ]
+
+    assert len(events) == 1
+    assert events[0]['id'] == '6'
+    assert events[0]['error']['code'] == -32001
+    assert events[0]['error']['message'] == 'Task not found'
diff --git a/tests/compat/v0_3/test_jsonrpc_transport.py b/tests/compat/v0_3/test_jsonrpc_transport.py
new file mode 100644
index 000000000..13d91162a
--- /dev/null
+++ b/tests/compat/v0_3/test_jsonrpc_transport.py
@@ -0,0 +1,569 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from a2a.client.errors import A2AClientError
+from a2a.compat.v0_3.jsonrpc_transport import CompatJsonRpcTransport
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    Message,
+    Role,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+)
+from a2a.utils.errors import InvalidParamsError
+
+
+@pytest.fixture
+def mock_httpx_client():
+    client = AsyncMock(spec=httpx.AsyncClient)
+    client.is_closed = False
+    return client
+
+
+@pytest.fixture
+def agent_card():
+    return AgentCard(capabilities=AgentCapabilities(extended_agent_card=True))
+
+
+@pytest.fixture
+def transport(mock_httpx_client, agent_card):
+    return CompatJsonRpcTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=agent_card,
+        url='http://example.com',
+    )
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_send_message_response_msg_parsing(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'messageId': 'msg-123',
+                'role': 'agent',
+                'parts': [{'text': 'Hello'}],
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+
+    expected_response = SendMessageResponse(
+        message=Message(
+            message_id='msg-123',
+            role=Role.ROLE_AGENT,
+            parts=[{'text': 'Hello'}],
+        )
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_send_message_task(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'id': 'task-123',
+                'contextId': 'ctx-456',
+                'status': {
+                    'state': 'working',
+                    'message': {
+                        'messageId': 'msg-123',
+                        'role': 'agent',
+                        'parts': [],
+                    },
+                },
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+
+    expected_response = SendMessageResponse(
+        task=Task(
+            id='task-123',
+            context_id='ctx-456',
+            status={
+                'state': TaskState.TASK_STATE_WORKING,
+                'message': {'message_id': 'msg-123', 'role': Role.ROLE_AGENT},
+            },
+        )
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_get_task(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'id': 'task-123',
+                'contextId': 'ctx-456',
+                'status': {
+                    'state': 'completed',
+                    'message': {
+                        'messageId': 'msg-789',
+                        'role': 'agent',
+                        'parts': [{'text': 'Done'}],
+                    },
+                },
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetTaskRequest(id='task-123')
+    response = await transport.get_task(req)
+
+    expected_response = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status={
+            'state': TaskState.TASK_STATE_COMPLETED,
+            'message': {
+                'message_id': 'msg-789',
+                'role': Role.ROLE_AGENT,
+                'parts': [{'text': 'Done'}],
+            },
+        },
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_cancel_task(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'id': 'task-123',
+                'contextId': 'ctx-456',
+                'status': {
+                    'state': 'canceled',
+                    'message': {
+                        'messageId': 'msg-789',
+                        'role': 'agent',
+                        'parts': [{'text': 'Cancelled'}],
+                    },
+                },
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = CancelTaskRequest(id='task-123')
+    response = await transport.cancel_task(req)
+
+    expected_response = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status={
+            'state': TaskState.TASK_STATE_CANCELED,
+            'message': {
+                'message_id': 'msg-789',
+                'role': Role.ROLE_AGENT,
+                'parts': [{'text': 'Cancelled'}],
+            },
+        },
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_create_task_push_notification_config(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'taskId': 'task-123',
+                'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+                'pushNotificationConfig': {
+                    'url': 'http://push',
+                    'id': 'push-123',
+                },
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = TaskPushNotificationConfig(
+        task_id='task-123', id='push-123', url='http://push'
+    )
+    response = await transport.create_task_push_notification_config(req)
+
+    expected_response = TaskPushNotificationConfig(
+        id='push-123', task_id='task-123', url='http://push'
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_get_task_push_notification_config(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'taskId': 'task-123',
+                'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+                'pushNotificationConfig': {
+                    'url': 'http://push',
+                    'id': 'push-123',
+                },
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetTaskPushNotificationConfigRequest(
+        task_id='task-123', id='push-123'
+    )
+    response = await transport.get_task_push_notification_config(req)
+
+    expected_response = TaskPushNotificationConfig(
+        id='push-123', task_id='task-123', url='http://push'
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_list_task_push_notification_configs(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': [
+                {
+                    'taskId': 'task-123',
+                    'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+                    'pushNotificationConfig': {
+                        'url': 'http://push',
+                        'id': 'push-123',
+                    },
+                }
+            ]
+        }
+
+    transport._send_request = mock_send_request
+
+    req = ListTaskPushNotificationConfigsRequest(task_id='task-123')
+    response = await transport.list_task_push_notification_configs(req)
+
+    expected_response = ListTaskPushNotificationConfigsResponse(
+        configs=[
+            TaskPushNotificationConfig(
+                id='push-123', task_id='task-123', url='http://push'
+            )
+        ]
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_delete_task_push_notification_config(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {'result': {}}
+
+    transport._send_request = mock_send_request
+
+    req = DeleteTaskPushNotificationConfigRequest(
+        task_id='task-123', id='push-123'
+    )
+    assert await transport.delete_task_push_notification_config(req) is None
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_get_extended_agent_card(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'result': {
+                'name': 'ExtendedAgent',
+                'url': 'http://agent',
+                'version': '1.0.0',
+                'description': 'Description',
+                'skills': [],
+                'defaultInputModes': [],
+                'defaultOutputModes': [],
+                'capabilities': {},
+                'supportsAuthenticatedExtendedCard': True,
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetExtendedAgentCardRequest()
+    response = await transport.get_extended_agent_card(req)
+
+    expected_response = AgentCard(
+        name='ExtendedAgent',
+        version='1.0.0',
+        description='Description',
+        capabilities=AgentCapabilities(extended_agent_card=True),
+    )
+    expected_response.supported_interfaces.add(
+        url='http://agent',
+        protocol_binding='JSONRPC',
+        protocol_version='0.3.0',
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_get_extended_agent_card_not_supported(
+    transport,
+):
+    transport.agent_card.capabilities.extended_agent_card = False
+
+    req = GetExtendedAgentCardRequest()
+    response = await transport.get_extended_agent_card(req)
+
+    assert response == transport.agent_card
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_get_extended_agent_card_method_name(
+    transport,
+):
+    """Verify the correct v0.3 method name 'agent/getAuthenticatedExtendedCard' is used."""
+    captured_request: dict | None = None
+
+    async def mock_send_request(data, *args, **kwargs):
+        nonlocal captured_request
+        captured_request = data
+        return {
+            'result': {
+                'name': 'ExtendedAgent',
+                'url': 'http://agent',
+                'version': '1.0.0',
+                'description': 'Description',
+                'skills': [],
+                'defaultInputModes': [],
+                'defaultOutputModes': [],
+                'capabilities': {},
+                'supportsAuthenticatedExtendedCard': True,
+            }
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetExtendedAgentCardRequest()
+    await transport.get_extended_agent_card(req)
+
+    assert captured_request is not None
+    assert captured_request['method'] == 'agent/getAuthenticatedExtendedCard'
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_close(transport, mock_httpx_client):
+    await transport.close()
+    mock_httpx_client.aclose.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_send_message_streaming(transport):
+    async def mock_send_stream_request(*args, **kwargs):
+        task = Task(id='task-123', context_id='ctx')
+        task.status.message.role = Role.ROLE_AGENT
+        yield StreamResponse(task=task)
+        yield StreamResponse(
+            message=Message(message_id='msg-123', role=Role.ROLE_AGENT)
+        )
+
+    transport._send_stream_request = mock_send_stream_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    events = [event async for event in transport.send_message_streaming(req)]
+
+    assert len(events) == 2
+    expected_task = Task(id='task-123', context_id='ctx')
+    expected_task.status.message.role = Role.ROLE_AGENT
+    assert events[0] == StreamResponse(task=expected_task)
+    assert events[1] == StreamResponse(
+        message=Message(message_id='msg-123', role=Role.ROLE_AGENT)
+    )
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_subscribe(transport):
+    async def mock_send_stream_request(*args, **kwargs):
+        task = Task(id='task-123', context_id='ctx')
+        task.status.message.role = Role.ROLE_AGENT
+        yield StreamResponse(task=task)
+
+    transport._send_stream_request = mock_send_stream_request
+
+    req = SubscribeToTaskRequest(id='task-123')
+    events = [event async for event in transport.subscribe(req)]
+
+    assert len(events) == 1
+    expected_task = Task(id='task-123', context_id='ctx')
+    expected_task.status.message.role = Role.ROLE_AGENT
+    assert events[0] == StreamResponse(task=expected_task)
+
+
+def test_compat_jsonrpc_transport_handle_http_error(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 400
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(A2AClientError) as exc_info:
+        transport._handle_http_error(error)
+
+    assert str(exc_info.value) == 'HTTP Error: 400'
+
+
+def test_compat_jsonrpc_transport_create_jsonrpc_error(transport):
+    error_dict = {'code': -32602, 'message': 'Invalid parameters'}
+
+    error = transport._create_jsonrpc_error(error_dict)
+    assert isinstance(error, InvalidParamsError)
+    assert str(error) == 'Invalid parameters'
+
+
+def test_compat_jsonrpc_transport_create_jsonrpc_error_unknown(transport):
+    error_dict = {'code': -12345, 'message': 'Unknown Error'}
+
+    error = transport._create_jsonrpc_error(error_dict)
+    assert isinstance(error, A2AClientError)
+    assert str(error) == 'Unknown Error'
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_list_tasks(transport):
+    with pytest.raises(NotImplementedError):
+        await transport.list_tasks(ListTasksRequest())
+
+
+@pytest.mark.asyncio
+async def test_compat_jsonrpc_transport_send_message_empty(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {'result': {}}
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+    assert response == SendMessageResponse()
+
+
+@pytest.mark.asyncio
+@patch('a2a.compat.v0_3.jsonrpc_transport.send_http_stream_request')
+async def test_compat_jsonrpc_transport_send_stream_request(
+    mock_send_http_stream_request, transport
+):
+    async def mock_generator(*args, **kwargs):
+        yield b'{"result": {"id": "task-123", "contextId": "ctx-456", "kind": "task", "status": {"state": "working", "message": {"messageId": "msg-1", "role": "agent", "parts": []}}}}'
+
+    mock_send_http_stream_request.return_value = mock_generator()
+
+    events = [
+        event
+        async for event in transport._send_stream_request({'some': 'data'})
+    ]
+
+    assert len(events) == 1
+    expected_task = Task(id='task-123', context_id='ctx-456')
+    expected_task.status.state = TaskState.TASK_STATE_WORKING
+    expected_task.status.message.message_id = 'msg-1'
+    expected_task.status.message.role = Role.ROLE_AGENT
+    assert events[0] == StreamResponse(task=expected_task)
+
+    mock_send_http_stream_request.assert_called_once_with(
+        transport.httpx_client,
+        'POST',
+        'http://example.com',
+        transport._handle_http_error,
+        json={'some': 'data'},
+        headers={'a2a-version': '0.3'},
+    )
+
+
+@pytest.mark.asyncio
+@patch('a2a.compat.v0_3.jsonrpc_transport.send_http_request')
+async def test_compat_jsonrpc_transport_send_request(
+    mock_send_http_request, transport
+):
+    mock_send_http_request.return_value = {'result': {'ok': True}}
+    mock_request = httpx.Request('POST', 'http://example.com')
+    transport.httpx_client.build_request.return_value = mock_request
+
+    res = await transport._send_request({'some': 'data'})
+    assert res == {'result': {'ok': True}}
+
+    transport.httpx_client.build_request.assert_called_once_with(
+        'POST',
+        'http://example.com',
+        json={'some': 'data'},
+        headers={'a2a-version': '0.3'},
+    )
+    mock_send_http_request.assert_called_once_with(
+        transport.httpx_client, mock_request, transport._handle_http_error
+    )
+
+
+@pytest.mark.asyncio
+@patch('a2a.compat.v0_3.jsonrpc_transport.send_http_request')
+async def test_compat_jsonrpc_transport_mirrors_extension_header(
+    mock_send_http_request, transport
+):
+    """Compat client must also emit the legacy X-A2A-Extensions header so
+    that v0.3 servers (which only know that name) understand the request."""
+    from a2a.client.client import ClientCallContext
+
+    mock_send_http_request.return_value = {'result': {'ok': True}}
+    transport.httpx_client.build_request.return_value = httpx.Request(
+        'POST', 'http://example.com'
+    )
+
+    context = ClientCallContext(
+        service_parameters={'A2A-Extensions': 'foo,bar'}
+    )
+
+    await transport._send_request({'some': 'data'}, context=context)
+
+    _, kwargs = transport.httpx_client.build_request.call_args
+    headers = kwargs['headers']
+    assert headers['A2A-Extensions'] == 'foo,bar'
+    assert headers['X-A2A-Extensions'] == 'foo,bar'
diff --git a/tests/compat/v0_3/test_proto_utils.py b/tests/compat/v0_3/test_proto_utils.py
new file mode 100644
index 000000000..ad394ba94
--- /dev/null
+++ b/tests/compat/v0_3/test_proto_utils.py
@@ -0,0 +1,804 @@
+"""
+This file was migrated from the a2a-python SDK version 0.3.
+It provides utilities for converting between legacy v0.3 Pydantic models and legacy v0.3 Protobuf definitions.
+"""
+
+import base64
+
+from unittest import mock
+
+import pytest
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2 as a2a_pb2, proto_utils, types
+from a2a.utils.errors import InvalidParamsError
+
+
+# --- Test Data ---
+
+
+@pytest.fixture
+def sample_message() -> types.Message:
+    return types.Message(
+        message_id='msg-1',
+        context_id='ctx-1',
+        task_id='task-1',
+        role=types.Role.user,
+        parts=[
+            types.Part(root=types.TextPart(text='Hello')),
+            types.Part(
+                root=types.FilePart(
+                    file=types.FileWithUri(
+                        uri='file:///test.txt',
+                        name='test.txt',
+                        mime_type='text/plain',
+                    ),
+                )
+            ),
+            types.Part(root=types.DataPart(data={'key': 'value'})),
+        ],
+        metadata={'source': 'test'},
+    )
+
+
+@pytest.fixture
+def sample_task(sample_message: types.Message) -> types.Task:
+    return types.Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=types.TaskStatus(
+            state=types.TaskState.working, message=sample_message
+        ),
+        history=[sample_message],
+        artifacts=[
+            types.Artifact(
+                artifact_id='art-1',
+                parts=[
+                    types.Part(root=types.TextPart(text='Artifact content'))
+                ],
+            )
+        ],
+        metadata={'source': 'test'},
+    )
+
+
+@pytest.fixture
+def sample_agent_card() -> types.AgentCard:
+    return types.AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        url='http://localhost',
+        version='1.0.0',
+        capabilities=types.AgentCapabilities(
+            streaming=True, push_notifications=True
+        ),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            types.AgentSkill(
+                id='skill1',
+                name='Test Skill',
+                description='A test skill',
+                tags=['test'],
+            )
+        ],
+        provider=types.AgentProvider(
+            organization='Test Org', url='http://test.org'
+        ),
+        security=[{'oauth_scheme': ['read', 'write']}],
+        security_schemes={
+            'oauth_scheme': types.SecurityScheme(
+                root=types.OAuth2SecurityScheme(
+                    flows=types.OAuthFlows(
+                        client_credentials=types.ClientCredentialsOAuthFlow(
+                            token_url='http://token.url',
+                            scopes={
+                                'read': 'Read access',
+                                'write': 'Write access',
+                            },
+                        )
+                    )
+                )
+            ),
+            'apiKey': types.SecurityScheme(
+                root=types.APIKeySecurityScheme(
+                    name='X-API-KEY', in_=types.In.header
+                )
+            ),
+            'httpAuth': types.SecurityScheme(
+                root=types.HTTPAuthSecurityScheme(scheme='bearer')
+            ),
+            'oidc': types.SecurityScheme(
+                root=types.OpenIdConnectSecurityScheme(
+                    open_id_connect_url='http://oidc.url'
+                )
+            ),
+        },
+        signatures=[
+            types.AgentCardSignature(
+                protected='protected_test',
+                signature='signature_test',
+                header={'alg': 'ES256'},
+            ),
+            types.AgentCardSignature(
+                protected='protected_val',
+                signature='signature_val',
+                header={'alg': 'ES256', 'kid': 'unique-key-identifier-123'},
+            ),
+        ],
+    )
+
+
+# --- Test Cases ---
+
+
+class TestToProto:
+    def test_part_unsupported_type(self):
+        """Test that ToProto.part raises ValueError for an unsupported Part type."""
+
+        class FakePartType:
+            kind = 'fake'
+
+        # Create a mock Part object that has a .root attribute pointing to the fake type
+        mock_part = mock.MagicMock(spec=types.Part)
+        mock_part.root = FakePartType()
+
+        with pytest.raises(ValueError, match='Unsupported part type'):
+            proto_utils.ToProto.part(mock_part)
+
+
+class TestFromProto:
+    def test_part_unsupported_type(self):
+        """Test that FromProto.part raises ValueError for an unsupported part type in proto."""
+        unsupported_proto_part = (
+            a2a_pb2.Part()
+        )  # An empty part with no oneof field set
+        with pytest.raises(ValueError, match='Unsupported part type'):
+            proto_utils.FromProto.part(unsupported_proto_part)
+
+    def test_task_query_params_invalid_name(self):
+        request = a2a_pb2.GetTaskRequest(name='invalid-name-format')
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.FromProto.task_query_params(request)
+        assert 'No task for' in str(exc_info.value)
+
+
+class TestProtoUtils:
+    def test_roundtrip_message(self, sample_message: types.Message):
+        """Test conversion of Message to proto and back."""
+        proto_msg = proto_utils.ToProto.message(sample_message)
+        assert isinstance(proto_msg, a2a_pb2.Message)
+
+        # Test file part handling
+        assert proto_msg.content[1].file.file_with_uri == 'file:///test.txt'
+        assert proto_msg.content[1].file.mime_type == 'text/plain'
+        assert proto_msg.content[1].file.name == 'test.txt'
+
+        roundtrip_msg = proto_utils.FromProto.message(proto_msg)
+        assert roundtrip_msg == sample_message
+
+    def test_enum_conversions(self):
+        """Test conversions for all enum types."""
+        assert (
+            proto_utils.ToProto.role(types.Role.agent)
+            == a2a_pb2.Role.ROLE_AGENT
+        )
+        assert (
+            proto_utils.FromProto.role(a2a_pb2.Role.ROLE_USER)
+            == types.Role.user
+        )
+
+        for state in types.TaskState:
+            proto_state = proto_utils.ToProto.task_state(state)
+            assert proto_utils.FromProto.task_state(proto_state) == state
+
+        # Test unknown state case
+        assert (
+            proto_utils.FromProto.task_state(
+                a2a_pb2.TaskState.TASK_STATE_UNSPECIFIED
+            )
+            == types.TaskState.unknown
+        )
+        assert (
+            proto_utils.ToProto.task_state(types.TaskState.unknown)
+            == a2a_pb2.TaskState.TASK_STATE_UNSPECIFIED
+        )
+
+    def test_oauth_flows_conversion(self):
+        """Test conversion of different OAuth2 flows."""
+        # Test password flow
+        password_flow = types.OAuthFlows(
+            password=types.PasswordOAuthFlow(
+                token_url='http://token.url', scopes={'read': 'Read'}
+            )
+        )
+        proto_password_flow = proto_utils.ToProto.oauth2_flows(password_flow)
+        assert proto_password_flow.HasField('password')
+
+        # Test implicit flow
+        implicit_flow = types.OAuthFlows(
+            implicit=types.ImplicitOAuthFlow(
+                authorization_url='http://auth.url', scopes={'read': 'Read'}
+            )
+        )
+        proto_implicit_flow = proto_utils.ToProto.oauth2_flows(implicit_flow)
+        assert proto_implicit_flow.HasField('implicit')
+
+        # Test authorization code flow
+        auth_code_flow = types.OAuthFlows(
+            authorization_code=types.AuthorizationCodeOAuthFlow(
+                authorization_url='http://auth.url',
+                token_url='http://token.url',
+                scopes={'read': 'read'},
+            )
+        )
+        proto_auth_code_flow = proto_utils.ToProto.oauth2_flows(auth_code_flow)
+        assert proto_auth_code_flow.HasField('authorization_code')
+
+        # Test no flow, e.g. a v1.0 device code flow converted to v0.3
+        proto_no_flow = proto_utils.ToProto.oauth2_flows(types.OAuthFlows())
+        assert proto_no_flow == a2a_pb2.OAuthFlows()
+        assert (
+            proto_utils.FromProto.oauth2_flows(proto_no_flow)
+            == types.OAuthFlows()
+        )
+
+        # Test FromProto
+        roundtrip_password = proto_utils.FromProto.oauth2_flows(
+            proto_password_flow
+        )
+        assert roundtrip_password.password is not None
+
+        roundtrip_implicit = proto_utils.FromProto.oauth2_flows(
+            proto_implicit_flow
+        )
+        assert roundtrip_implicit.implicit is not None
+
+    def test_task_id_params_from_proto_invalid_name(self):
+        request = a2a_pb2.CancelTaskRequest(name='invalid-name-format')
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.FromProto.task_id_params(request)
+        assert 'No task for' in str(exc_info.value)
+
+    def test_task_push_config_from_proto_invalid_parent(self):
+        request = a2a_pb2.TaskPushNotificationConfig(name='invalid-name-format')
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.FromProto.task_push_notification_config(request)
+        assert 'Bad TaskPushNotificationConfig resource name' in str(
+            exc_info.value
+        )
+
+    @pytest.mark.parametrize(
+        ('history_length', 'expected'), [(0, None), (5, 5)]
+    )
+    def test_message_send_configuration_history_length(
+        self, history_length: int, expected: int | None
+    ):
+        """A v0.3 history_length of 0 means unlimited, as in task_query_params."""
+        config = proto_utils.FromProto.message_send_configuration(
+            a2a_pb2.SendMessageConfiguration(history_length=history_length)
+        )
+        assert config.history_length == expected
+
+    def test_message_send_params_without_configuration(self):
+        """An unset configuration stays None so the send defaults to blocking."""
+        params = proto_utils.FromProto.message_send_params(
+            a2a_pb2.SendMessageRequest(request=a2a_pb2.Message(message_id='m'))
+        )
+        assert params.configuration is None
+
+    def test_task_status_without_message(self):
+        """An unset status message stays None instead of an empty message."""
+        status = proto_utils.FromProto.task_status(
+            a2a_pb2.TaskStatus(state=a2a_pb2.TASK_STATE_WORKING)
+        )
+        assert status.message is None
+
+    def test_agent_card_without_provider(self):
+        """An unset provider stays None instead of an empty provider."""
+        card = proto_utils.FromProto.agent_card(a2a_pb2.AgentCard(name='a'))
+        assert card.provider is None
+
+    def test_none_handling(self):
+        """Test that None inputs are handled gracefully."""
+        assert proto_utils.ToProto.message(None) is None
+        assert proto_utils.ToProto.metadata(None) is None
+        assert proto_utils.ToProto.provider(None) is None
+        assert proto_utils.ToProto.security(None) is None
+        assert proto_utils.ToProto.security_schemes(None) is None
+        assert proto_utils.ToProto.message_send_configuration(None) is None
+
+    def test_metadata_conversion(self):
+        """Test metadata conversion with various data types."""
+        metadata = {
+            'null_value': None,
+            'bool_value': True,
+            'int_value': 42,
+            'float_value': 3.14,
+            'string_value': 'hello',
+            'dict_value': {'nested': 'dict', 'count': 10},
+            'list_value': [1, 'two', 3.0, True, None],
+            'tuple_value': (1, 2, 3),
+            'complex_list': [
+                {'name': 'item1', 'values': [1, 2, 3]},
+                {'name': 'item2', 'values': [4, 5, 6]},
+            ],
+        }
+
+        # Convert to proto
+        proto_metadata = proto_utils.ToProto.metadata(metadata)
+        assert proto_metadata is not None
+
+        # Convert back to Python
+        roundtrip_metadata = proto_utils.FromProto.metadata(proto_metadata)
+
+        # Verify all values are preserved correctly
+        assert roundtrip_metadata['null_value'] is None
+        assert roundtrip_metadata['bool_value'] is True
+        assert roundtrip_metadata['int_value'] == 42
+        assert roundtrip_metadata['float_value'] == 3.14
+        assert roundtrip_metadata['string_value'] == 'hello'
+        assert roundtrip_metadata['dict_value']['nested'] == 'dict'
+        assert roundtrip_metadata['dict_value']['count'] == 10
+        assert roundtrip_metadata['list_value'] == [1, 'two', 3.0, True, None]
+        assert roundtrip_metadata['tuple_value'] == [
+            1,
+            2,
+            3,
+        ]  # tuples become lists
+        assert len(roundtrip_metadata['complex_list']) == 2
+        assert roundtrip_metadata['complex_list'][0]['name'] == 'item1'
+
+    def test_metadata_with_custom_objects(self):
+        """Test metadata conversion with custom objects using preprocessing utility."""
+
+        class CustomObject:
+            def __str__(self):
+                return 'custom_object_str'
+
+            def __repr__(self):
+                return 'CustomObject()'
+
+        metadata = {
+            'custom_obj': CustomObject(),
+            'list_with_custom': [1, CustomObject(), 'text'],
+            'nested_custom': {'obj': CustomObject(), 'normal': 'value'},
+        }
+
+        # Use preprocessing utility to make it serializable
+        serializable_metadata = proto_utils.make_dict_serializable(metadata)
+
+        # Convert to proto
+        proto_metadata = proto_utils.ToProto.metadata(serializable_metadata)
+        assert proto_metadata is not None
+
+        # Convert back to Python
+        roundtrip_metadata = proto_utils.FromProto.metadata(proto_metadata)
+
+        # Custom objects should be converted to strings
+        assert roundtrip_metadata['custom_obj'] == 'custom_object_str'
+        assert roundtrip_metadata['list_with_custom'] == [
+            1,
+            'custom_object_str',
+            'text',
+        ]
+        assert roundtrip_metadata['nested_custom']['obj'] == 'custom_object_str'
+        assert roundtrip_metadata['nested_custom']['normal'] == 'value'
+
+    def test_metadata_edge_cases(self):
+        """Test metadata conversion with edge cases."""
+        metadata = {
+            'empty_dict': {},
+            'empty_list': [],
+            'zero': 0,
+            'false': False,
+            'empty_string': '',
+            'unicode_string': 'string test',
+            'safe_number': 9007199254740991,  # JavaScript MAX_SAFE_INTEGER
+            'negative_number': -42,
+            'float_precision': 0.123456789,
+            'numeric_string': '12345',
+        }
+
+        # Convert to proto and back
+        proto_metadata = proto_utils.ToProto.metadata(metadata)
+        roundtrip_metadata = proto_utils.FromProto.metadata(proto_metadata)
+
+        # Verify edge cases are handled correctly
+        assert roundtrip_metadata['empty_dict'] == {}
+        assert roundtrip_metadata['empty_list'] == []
+        assert roundtrip_metadata['zero'] == 0
+        assert roundtrip_metadata['false'] is False
+        assert roundtrip_metadata['empty_string'] == ''
+        assert roundtrip_metadata['unicode_string'] == 'string test'
+        assert roundtrip_metadata['safe_number'] == 9007199254740991
+        assert roundtrip_metadata['negative_number'] == -42
+        assert abs(roundtrip_metadata['float_precision'] - 0.123456789) < 1e-10
+        assert roundtrip_metadata['numeric_string'] == '12345'
+
+    def test_make_dict_serializable(self):
+        """Test the make_dict_serializable utility function."""
+
+        class CustomObject:
+            def __str__(self):
+                return 'custom_str'
+
+        test_data = {
+            'string': 'hello',
+            'int': 42,
+            'float': 3.14,
+            'bool': True,
+            'none': None,
+            'custom': CustomObject(),
+            'list': [1, 'two', CustomObject()],
+            'tuple': (1, 2, CustomObject()),
+            'nested': {'inner_custom': CustomObject(), 'inner_normal': 'value'},
+        }
+
+        result = proto_utils.make_dict_serializable(test_data)
+
+        # Basic types should be unchanged
+        assert result['string'] == 'hello'
+        assert result['int'] == 42
+        assert result['float'] == 3.14
+        assert result['bool'] is True
+        assert result['none'] is None
+
+        # Custom objects should be converted to strings
+        assert result['custom'] == 'custom_str'
+        assert result['list'] == [1, 'two', 'custom_str']
+        assert result['tuple'] == [1, 2, 'custom_str']  # tuples become lists
+        assert result['nested']['inner_custom'] == 'custom_str'
+        assert result['nested']['inner_normal'] == 'value'
+
+    def test_normalize_large_integers_to_strings(self):
+        """Test the normalize_large_integers_to_strings utility function."""
+
+        test_data = {
+            'small_int': 42,
+            'large_int': 9999999999999999999,  # > 15 digits
+            'negative_large': -9999999999999999999,
+            'float': 3.14,
+            'string': 'hello',
+            'list': [123, 9999999999999999999, 'text'],
+            'nested': {'inner_large': 9999999999999999999, 'inner_small': 100},
+        }
+
+        result = proto_utils.normalize_large_integers_to_strings(test_data)
+
+        # Small integers should remain as integers
+        assert result['small_int'] == 42
+        assert isinstance(result['small_int'], int)
+
+        # Large integers should be converted to strings
+        assert result['large_int'] == '9999999999999999999'
+        assert isinstance(result['large_int'], str)
+        assert result['negative_large'] == '-9999999999999999999'
+        assert isinstance(result['negative_large'], str)
+
+        # Other types should be unchanged
+        assert result['float'] == 3.14
+        assert result['string'] == 'hello'
+
+        # Lists should be processed recursively
+        assert result['list'] == [123, '9999999999999999999', 'text']
+
+        # Nested dicts should be processed recursively
+        assert result['nested']['inner_large'] == '9999999999999999999'
+        assert result['nested']['inner_small'] == 100
+
+    def test_parse_string_integers_in_dict(self):
+        """Test the parse_string_integers_in_dict utility function."""
+
+        test_data = {
+            'regular_string': 'hello',
+            'numeric_string_small': '123',  # small, should stay as string
+            'numeric_string_large': '9999999999999999999',  # > 15 digits, should become int
+            'negative_large_string': '-9999999999999999999',
+            'float_string': '3.14',  # not all digits, should stay as string
+            'mixed_string': '123abc',  # not all digits, should stay as string
+            'int': 42,
+            'list': ['hello', '9999999999999999999', '123'],
+            'nested': {
+                'inner_large_string': '9999999999999999999',
+                'inner_regular': 'value',
+            },
+        }
+
+        result = proto_utils.parse_string_integers_in_dict(test_data)
+
+        # Regular strings should remain unchanged
+        assert result['regular_string'] == 'hello'
+        assert (
+            result['numeric_string_small'] == '123'
+        )  # too small, stays string
+        assert result['float_string'] == '3.14'  # not all digits
+        assert result['mixed_string'] == '123abc'  # not all digits
+
+        # Large numeric strings should be converted to integers
+        assert result['numeric_string_large'] == 9999999999999999999
+        assert isinstance(result['numeric_string_large'], int)
+        assert result['negative_large_string'] == -9999999999999999999
+        assert isinstance(result['negative_large_string'], int)
+
+        # Other types should be unchanged
+        assert result['int'] == 42
+
+        # Lists should be processed recursively
+        assert result['list'] == ['hello', 9999999999999999999, '123']
+
+        # Nested dicts should be processed recursively
+        assert result['nested']['inner_large_string'] == 9999999999999999999
+        assert result['nested']['inner_regular'] == 'value'
+
+    def test_large_integer_roundtrip_with_utilities(self):
+        """Test large integer handling with preprocessing and post-processing utilities."""
+
+        original_data = {
+            'large_int': 9999999999999999999,
+            'small_int': 42,
+            'nested': {'another_large': 12345678901234567890, 'normal': 'text'},
+        }
+
+        # Step 1: Preprocess to convert large integers to strings
+        preprocessed = proto_utils.normalize_large_integers_to_strings(
+            original_data
+        )
+
+        # Step 2: Convert to proto
+        proto_metadata = proto_utils.ToProto.metadata(preprocessed)
+        assert proto_metadata is not None
+
+        # Step 3: Convert back from proto
+        dict_from_proto = proto_utils.FromProto.metadata(proto_metadata)
+
+        # Step 4: Post-process to convert large integer strings back to integers
+        final_result = proto_utils.parse_string_integers_in_dict(
+            dict_from_proto
+        )
+
+        # Verify roundtrip preserved the original data
+        assert final_result['large_int'] == 9999999999999999999
+        assert isinstance(final_result['large_int'], int)
+        assert final_result['small_int'] == 42
+        assert final_result['nested']['another_large'] == 12345678901234567890
+        assert isinstance(final_result['nested']['another_large'], int)
+        assert final_result['nested']['normal'] == 'text'
+
+    def test_task_conversion_roundtrip(
+        self, sample_task: types.Task, sample_message: types.Message
+    ):
+        """Test conversion of Task to proto and back."""
+        proto_task = proto_utils.ToProto.task(sample_task)
+        assert isinstance(proto_task, a2a_pb2.Task)
+
+        roundtrip_task = proto_utils.FromProto.task(proto_task)
+        assert roundtrip_task.id == 'task-1'
+        assert roundtrip_task.context_id == 'ctx-1'
+        assert roundtrip_task.status == types.TaskStatus(
+            state=types.TaskState.working, message=sample_message
+        )
+        assert roundtrip_task.history == sample_task.history
+        assert roundtrip_task.artifacts == [
+            types.Artifact(
+                artifact_id='art-1',
+                description='',
+                metadata={},
+                name='',
+                parts=[
+                    types.Part(root=types.TextPart(text='Artifact content'))
+                ],
+            )
+        ]
+        assert roundtrip_task.metadata == {'source': 'test'}
+
+    def test_agent_card_conversion_roundtrip(
+        self, sample_agent_card: types.AgentCard
+    ):
+        """Test conversion of AgentCard to proto and back."""
+        proto_card = proto_utils.ToProto.agent_card(sample_agent_card)
+        assert isinstance(proto_card, a2a_pb2.AgentCard)
+
+        roundtrip_card = proto_utils.FromProto.agent_card(proto_card)
+        assert roundtrip_card.name == 'Test Agent'
+        assert roundtrip_card.description == 'A test agent'
+        assert roundtrip_card.url == 'http://localhost'
+        assert roundtrip_card.version == '1.0.0'
+        assert roundtrip_card.capabilities == types.AgentCapabilities(
+            extensions=[], streaming=True, push_notifications=True
+        )
+        assert roundtrip_card.default_input_modes == ['text/plain']
+        assert roundtrip_card.default_output_modes == ['text/plain']
+        assert roundtrip_card.skills == [
+            types.AgentSkill(
+                id='skill1',
+                name='Test Skill',
+                description='A test skill',
+                tags=['test'],
+                examples=[],
+                input_modes=[],
+                output_modes=[],
+            )
+        ]
+        assert roundtrip_card.provider == types.AgentProvider(
+            organization='Test Org', url='http://test.org'
+        )
+        assert roundtrip_card.security == [{'oauth_scheme': ['read', 'write']}]
+
+        # Normalized version of security_schemes. None fields are filled with defaults.
+        expected_security_schemes = {
+            'oauth_scheme': types.SecurityScheme(
+                root=types.OAuth2SecurityScheme(
+                    description='',
+                    flows=types.OAuthFlows(
+                        client_credentials=types.ClientCredentialsOAuthFlow(
+                            refresh_url='',
+                            scopes={
+                                'write': 'Write access',
+                                'read': 'Read access',
+                            },
+                            token_url='http://token.url',
+                        ),
+                    ),
+                )
+            ),
+            'apiKey': types.SecurityScheme(
+                root=types.APIKeySecurityScheme(
+                    description='',
+                    in_=types.In.header,
+                    name='X-API-KEY',
+                )
+            ),
+            'httpAuth': types.SecurityScheme(
+                root=types.HTTPAuthSecurityScheme(
+                    bearer_format='',
+                    description='',
+                    scheme='bearer',
+                )
+            ),
+            'oidc': types.SecurityScheme(
+                root=types.OpenIdConnectSecurityScheme(
+                    description='',
+                    open_id_connect_url='http://oidc.url',
+                )
+            ),
+        }
+        assert roundtrip_card.security_schemes == expected_security_schemes
+        assert roundtrip_card.signatures == [
+            types.AgentCardSignature(
+                protected='protected_test',
+                signature='signature_test',
+                header={'alg': 'ES256'},
+            ),
+            types.AgentCardSignature(
+                protected='protected_val',
+                signature='signature_val',
+                header={'alg': 'ES256', 'kid': 'unique-key-identifier-123'},
+            ),
+        ]
+
+    def test_task_status_timestamp_roundtrip(self):
+        """TaskStatus.timestamp survives conversion to proto and back."""
+        status = types.TaskStatus(
+            state=types.TaskState.working, timestamp='2026-03-15T10:30:00Z'
+        )
+
+        proto_status = proto_utils.ToProto.task_status(status)
+        assert proto_status.HasField('timestamp')
+
+        roundtrip_status = proto_utils.FromProto.task_status(proto_status)
+        assert roundtrip_status.timestamp == '2026-03-15T10:30:00Z'
+
+    def test_agent_card_optional_fields_roundtrip(
+        self, sample_agent_card: types.AgentCard
+    ):
+        """icon_url, oauth2_metadata_url and skill security survive conversion."""
+        card = sample_agent_card.model_copy(deep=True)
+        card.icon_url = 'http://localhost/icon.png'
+        card.skills[0].security = [{'oauth_scheme': ['read']}]
+        card.security_schemes[
+            'oauth_scheme'
+        ].root.oauth2_metadata_url = (
+            'http://localhost/.well-known/oauth-authorization-server'
+        )
+
+        roundtrip_card = proto_utils.FromProto.agent_card(
+            proto_utils.ToProto.agent_card(card)
+        )
+        assert roundtrip_card.icon_url == 'http://localhost/icon.png'
+        assert roundtrip_card.skills[0].security == [{'oauth_scheme': ['read']}]
+        assert (
+            roundtrip_card.security_schemes[
+                'oauth_scheme'
+            ].root.oauth2_metadata_url
+            == 'http://localhost/.well-known/oauth-authorization-server'
+        )
+
+    @pytest.mark.parametrize(
+        'signature_data, expected_data',
+        [
+            (
+                types.AgentCardSignature(
+                    protected='protected_val',
+                    signature='signature_val',
+                    header={'alg': 'ES256'},
+                ),
+                types.AgentCardSignature(
+                    protected='protected_val',
+                    signature='signature_val',
+                    header={'alg': 'ES256'},
+                ),
+            ),
+            (
+                types.AgentCardSignature(
+                    protected='protected_val',
+                    signature='signature_val',
+                    header=None,
+                ),
+                types.AgentCardSignature(
+                    protected='protected_val',
+                    signature='signature_val',
+                    header={},
+                ),
+            ),
+            (
+                types.AgentCardSignature(
+                    protected='',
+                    signature='',
+                    header={},
+                ),
+                types.AgentCardSignature(
+                    protected='',
+                    signature='',
+                    header={},
+                ),
+            ),
+        ],
+    )
+    def test_agent_card_signature_conversion_roundtrip(
+        self, signature_data, expected_data
+    ):
+        """Test conversion of AgentCardSignature to proto and back."""
+        proto_signature = proto_utils.ToProto.agent_card_signature(
+            signature_data
+        )
+        assert isinstance(proto_signature, a2a_pb2.AgentCardSignature)
+        roundtrip_signature = proto_utils.FromProto.agent_card_signature(
+            proto_signature
+        )
+        assert roundtrip_signature == expected_data
+
+    def test_roundtrip_message_with_file_bytes(self):
+        """Test round-trip conversion of Message with FileWithBytes."""
+        file_content = b'binary data'
+        b64_content = base64.b64encode(file_content).decode('utf-8')
+        message = types.Message(
+            message_id='msg-bytes',
+            role=types.Role.user,
+            parts=[
+                types.Part(
+                    root=types.FilePart(
+                        file=types.FileWithBytes(
+                            bytes=b64_content,
+                            name='file.bin',
+                            mime_type='application/octet-stream',
+                        )
+                    )
+                )
+            ],
+            metadata={},
+        )
+
+        proto_msg = proto_utils.ToProto.message(message)
+        # Current implementation just encodes the string to bytes
+        assert proto_msg.content[0].file.file_with_bytes == b64_content.encode(
+            'utf-8'
+        )
+
+        roundtrip_msg = proto_utils.FromProto.message(proto_msg)
+        assert roundtrip_msg.message_id == message.message_id
+        assert roundtrip_msg.role == message.role
+        assert roundtrip_msg.metadata == message.metadata
+        assert (
+            roundtrip_msg.parts[0].root.file.bytes
+            == message.parts[0].root.file.bytes
+        )
diff --git a/tests/compat/v0_3/test_request_handler.py b/tests/compat/v0_3/test_request_handler.py
new file mode 100644
index 000000000..002797338
--- /dev/null
+++ b/tests/compat/v0_3/test_request_handler.py
@@ -0,0 +1,466 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from a2a.auth.user import UnauthenticatedUser
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.request_handler import RequestHandler03
+from a2a.server.agent_execution import AgentExecutor
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers import DefaultRequestHandlerV2
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.tasks import InMemoryPushNotificationConfigStore, TaskStore
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    ListTaskPushNotificationConfigsResponse as V10ListPushConfigsResp,
+    Message as V10Message,
+    Part as V10Part,
+    Task as V10Task,
+    TaskPushNotificationConfig as V10PushConfig,
+    TaskState as V10TaskState,
+    TaskStatus as V10TaskStatus,
+)
+from a2a.utils.errors import TaskNotFoundError
+
+
+@pytest.fixture
+def mock_core_handler():
+    handler = AsyncMock(spec=RequestHandler)
+
+    handler.agent_card = AgentCard(
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            extended_agent_card=True,
+        )
+    )
+    return handler
+
+
+@pytest.fixture
+def v03_handler(mock_core_handler):
+    return RequestHandler03(request_handler=mock_core_handler)
+
+
+@pytest.fixture
+def mock_context():
+    return MagicMock(spec=ServerCallContext)
+
+
+@pytest.mark.anyio
+async def test_on_message_send_returns_message(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.SendMessageRequest(
+        id='req-1',
+        method='message/send',
+        params=types_v03.MessageSendParams(
+            message=types_v03.Message(
+                message_id='msg-1',
+                role='user',
+                parts=[types_v03.TextPart(text='Hello')],
+            )
+        ),
+    )
+
+    mock_core_handler.on_message_send.return_value = V10Message(
+        message_id='msg-2', role=2, parts=[V10Part(text='Hi there')]
+    )
+
+    result = await v03_handler.on_message_send(v03_req, mock_context)
+
+    assert isinstance(result, types_v03.Message)
+    assert result.message_id == 'msg-2'
+    assert result.role == 'agent'
+    assert len(result.parts) == 1
+    assert result.parts[0].root.text == 'Hi there'
+
+
+@pytest.mark.anyio
+async def test_on_message_send_returns_task(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.SendMessageRequest(
+        id='req-1',
+        method='message/send',
+        params=types_v03.MessageSendParams(
+            message=types_v03.Message(
+                message_id='msg-1',
+                role='user',
+                parts=[types_v03.TextPart(text='Hello')],
+            )
+        ),
+    )
+
+    mock_core_handler.on_message_send.return_value = V10Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=V10TaskStatus(state=V10TaskState.TASK_STATE_WORKING),
+    )
+
+    result = await v03_handler.on_message_send(v03_req, mock_context)
+
+    assert isinstance(result, types_v03.Task)
+    assert result.id == 'task-1'
+    assert result.context_id == 'ctx-1'
+    assert result.status.state == 'working'
+
+
+@pytest.mark.anyio
+async def test_on_message_send_stream(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.SendMessageRequest(
+        id='req-1',
+        method='message/send',
+        params=types_v03.MessageSendParams(
+            message=types_v03.Message(
+                message_id='msg-1',
+                role='user',
+                parts=[types_v03.TextPart(text='Hello')],
+            )
+        ),
+    )
+
+    async def mock_stream(*args, **kwargs):
+        yield V10Message(
+            message_id='msg-2',
+            role=2,
+            parts=[V10Part(text='Chunk 1')],
+        )
+        yield V10Message(
+            message_id='msg-2',
+            role=2,
+            parts=[V10Part(text='Chunk 2')],
+        )
+
+    mock_core_handler.on_message_send_stream.side_effect = mock_stream
+
+    results = [
+        chunk
+        async for chunk in v03_handler.on_message_send_stream(
+            v03_req, mock_context
+        )
+    ]
+
+    assert len(results) == 2
+    assert all(
+        isinstance(r, types_v03.SendStreamingMessageSuccessResponse)
+        for r in results
+    )
+    assert results[0].result.parts[0].root.text == 'Chunk 1'
+    assert results[1].result.parts[0].root.text == 'Chunk 2'
+
+
+@pytest.mark.anyio
+async def test_on_cancel_task(v03_handler, mock_core_handler, mock_context):
+    v03_req = types_v03.CancelTaskRequest(
+        id='req-1',
+        method='tasks/cancel',
+        params=types_v03.TaskIdParams(id='task-1'),
+    )
+
+    mock_core_handler.on_cancel_task.return_value = V10Task(
+        id='task-1',
+        status=V10TaskStatus(state=V10TaskState.TASK_STATE_CANCELED),
+    )
+
+    result = await v03_handler.on_cancel_task(v03_req, mock_context)
+
+    assert isinstance(result, types_v03.Task)
+    assert result.id == 'task-1'
+    assert result.status.state == 'canceled'
+
+
+@pytest.mark.anyio
+async def test_on_cancel_task_not_found(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.CancelTaskRequest(
+        id='req-1',
+        method='tasks/cancel',
+        params=types_v03.TaskIdParams(id='task-1'),
+    )
+
+    mock_core_handler.on_cancel_task.return_value = None
+
+    with pytest.raises(TaskNotFoundError):
+        await v03_handler.on_cancel_task(v03_req, mock_context)
+
+
+@pytest.mark.anyio
+async def test_on_subscribe_to_task(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.TaskResubscriptionRequest(
+        id='req-1',
+        method='tasks/resubscribe',
+        params=types_v03.TaskIdParams(id='task-1'),
+    )
+
+    async def mock_stream(*args, **kwargs):
+        yield V10Message(
+            message_id='msg-2',
+            role=2,
+            parts=[V10Part(text='Update 1')],
+        )
+
+    mock_core_handler.on_subscribe_to_task.side_effect = mock_stream
+
+    results = [
+        chunk
+        async for chunk in v03_handler.on_subscribe_to_task(
+            v03_req, mock_context
+        )
+    ]
+
+    assert len(results) == 1
+    assert results[0].result.parts[0].root.text == 'Update 1'
+
+
+@pytest.mark.anyio
+async def test_on_get_task_push_notification_config(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.GetTaskPushNotificationConfigRequest(
+        id='req-1',
+        method='tasks/pushNotificationConfig/get',
+        params=types_v03.GetTaskPushNotificationConfigParams(
+            id='task-1', push_notification_config_id='push-1'
+        ),
+    )
+
+    mock_core_handler.on_get_task_push_notification_config.return_value = (
+        V10PushConfig(id='push-1', url='http://example.com')
+    )
+
+    result = await v03_handler.on_get_task_push_notification_config(
+        v03_req, mock_context
+    )
+
+    assert isinstance(result, types_v03.TaskPushNotificationConfig)
+    assert result.push_notification_config.id == 'push-1'
+    assert result.push_notification_config.url == 'http://example.com'
+
+
+@pytest.fixture
+def v03_handler_with_push_store():
+    task_store = AsyncMock(spec=TaskStore)
+    task_store.get.return_value = V10Task(id='task-1', context_id='ctx-1')
+    core_handler = DefaultRequestHandlerV2(
+        agent_executor=MagicMock(spec=AgentExecutor),
+        task_store=task_store,
+        push_config_store=InMemoryPushNotificationConfigStore(),
+        agent_card=AgentCard(
+            capabilities=AgentCapabilities(push_notifications=True)
+        ),
+    )
+    return RequestHandler03(request_handler=core_handler)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    ('config_ids', 'expected_id'),
+    [
+        ([None], 'task-1'),
+        (['cfg-1'], 'cfg-1'),
+        (['cfg-1', None], 'task-1'),
+    ],
+)
+async def test_on_get_task_push_notification_config_by_task_id(
+    v03_handler_with_push_store, config_ids, expected_id
+):
+    """Without a config id, prefer the config stored under the task id."""
+    context = ServerCallContext(user=UnauthenticatedUser())
+    for config_id in config_ids:
+        await v03_handler_with_push_store.on_create_task_push_notification_config(
+            types_v03.SetTaskPushNotificationConfigRequest(
+                id='req-1',
+                method='tasks/pushNotificationConfig/set',
+                params=types_v03.TaskPushNotificationConfig(
+                    task_id='task-1',
+                    push_notification_config=types_v03.PushNotificationConfig(
+                        id=config_id, url='http://example.com'
+                    ),
+                ),
+            ),
+            context,
+        )
+
+    result = (
+        await v03_handler_with_push_store.on_get_task_push_notification_config(
+            types_v03.GetTaskPushNotificationConfigRequest(
+                id='req-2',
+                method='tasks/pushNotificationConfig/get',
+                params=types_v03.TaskIdParams(id='task-1'),
+            ),
+            context,
+        )
+    )
+
+    assert result.push_notification_config.id == expected_id
+
+
+@pytest.mark.anyio
+async def test_on_get_task_push_notification_config_by_task_id_none_set(
+    v03_handler_with_push_store,
+):
+    with pytest.raises(TaskNotFoundError):
+        await v03_handler_with_push_store.on_get_task_push_notification_config(
+            types_v03.GetTaskPushNotificationConfigRequest(
+                id='req-1',
+                method='tasks/pushNotificationConfig/get',
+                params=types_v03.TaskIdParams(id='task-1'),
+            ),
+            ServerCallContext(user=UnauthenticatedUser()),
+        )
+
+
+@pytest.mark.anyio
+async def test_on_create_task_push_notification_config(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.SetTaskPushNotificationConfigRequest(
+        id='req-1',
+        method='tasks/pushNotificationConfig/set',
+        params=types_v03.TaskPushNotificationConfig(
+            task_id='task-1',
+            push_notification_config=types_v03.PushNotificationConfig(
+                url='http://example.com'
+            ),
+        ),
+    )
+
+    mock_core_handler.on_create_task_push_notification_config.return_value = (
+        V10PushConfig(id='push-1', url='http://example.com')
+    )
+
+    result = await v03_handler.on_create_task_push_notification_config(
+        v03_req, mock_context
+    )
+
+    assert isinstance(result, types_v03.TaskPushNotificationConfig)
+    assert result.push_notification_config.id == 'push-1'
+    assert result.push_notification_config.url == 'http://example.com'
+
+
+@pytest.mark.anyio
+async def test_on_get_task(v03_handler, mock_core_handler, mock_context):
+    v03_req = types_v03.GetTaskRequest(
+        id='req-1',
+        method='tasks/get',
+        params=types_v03.TaskQueryParams(id='task-1'),
+    )
+
+    mock_core_handler.on_get_task.return_value = V10Task(
+        id='task-1', status=V10TaskStatus(state=V10TaskState.TASK_STATE_WORKING)
+    )
+
+    result = await v03_handler.on_get_task(v03_req, mock_context)
+
+    assert isinstance(result, types_v03.Task)
+    assert result.id == 'task-1'
+    assert result.status.state == 'working'
+
+
+@pytest.mark.anyio
+async def test_on_get_task_not_found(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.GetTaskRequest(
+        id='req-1',
+        method='tasks/get',
+        params=types_v03.TaskQueryParams(id='task-1'),
+    )
+
+    mock_core_handler.on_get_task.return_value = None
+
+    with pytest.raises(TaskNotFoundError):
+        await v03_handler.on_get_task(v03_req, mock_context)
+
+
+@pytest.mark.anyio
+async def test_on_list_task_push_notification_configs(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.ListTaskPushNotificationConfigRequest(
+        id='req-1',
+        method='tasks/pushNotificationConfig/list',
+        params=types_v03.ListTaskPushNotificationConfigParams(id='task-1'),
+    )
+
+    mock_core_handler.on_list_task_push_notification_configs.return_value = (
+        V10ListPushConfigsResp(
+            configs=[
+                V10PushConfig(id='push-1', url='http://example1.com'),
+                V10PushConfig(id='push-2', url='http://example2.com'),
+            ]
+        )
+    )
+
+    result = await v03_handler.on_list_task_push_notification_configs(
+        v03_req, mock_context
+    )
+
+    assert isinstance(result, list)
+    assert len(result) == 2
+    assert result[0].push_notification_config.id == 'push-1'
+    assert result[1].push_notification_config.id == 'push-2'
+
+
+@pytest.mark.anyio
+async def test_on_delete_task_push_notification_config(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.DeleteTaskPushNotificationConfigRequest(
+        id='req-1',
+        method='tasks/pushNotificationConfig/delete',
+        params=types_v03.DeleteTaskPushNotificationConfigParams(
+            id='task-1', push_notification_config_id='push-1'
+        ),
+    )
+
+    mock_core_handler.on_delete_task_push_notification_config.return_value = (
+        None
+    )
+
+    result = await v03_handler.on_delete_task_push_notification_config(
+        v03_req, mock_context
+    )
+
+    assert result is None
+    mock_core_handler.on_delete_task_push_notification_config.assert_called_once()
+
+
+@pytest.mark.anyio
+async def test_on_get_extended_agent_card_success(
+    v03_handler, mock_core_handler, mock_context
+):
+    v03_req = types_v03.GetAuthenticatedExtendedCardRequest(id=0)
+
+    mock_core_handler.on_get_extended_agent_card.return_value = AgentCard(
+        name='Extended Agent',
+        description='An extended test agent',
+        version='1.0.0',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://jsonrpc.v03.com',
+                protocol_version='0.3',
+            )
+        ],
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            extended_agent_card=True,
+        ),
+    )
+
+    result = await v03_handler.on_get_extended_agent_card(v03_req, mock_context)
+
+    assert isinstance(result, types_v03.AgentCard)
+    assert result.name == 'Extended Agent'
+    assert result.capabilities.streaming is True
+    assert result.capabilities.push_notifications is True
+    mock_core_handler.on_get_extended_agent_card.assert_called_once()
diff --git a/tests/compat/v0_3/test_rest_handler.py b/tests/compat/v0_3/test_rest_handler.py
new file mode 100644
index 000000000..c8374f0e2
--- /dev/null
+++ b/tests/compat/v0_3/test_rest_handler.py
@@ -0,0 +1,427 @@
+import json
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.rest_handler import REST03Handler
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.types.a2a_pb2 import AgentCard
+from a2a.utils.errors import InvalidParamsError
+
+
+@pytest.fixture
+def mock_core_handler():
+    return AsyncMock(spec=RequestHandler)
+
+
+@pytest.fixture
+def agent_card():
+    card = MagicMock(spec=AgentCard)
+    card.capabilities = MagicMock()
+    card.capabilities.streaming = True
+    card.capabilities.push_notifications = True
+    return card
+
+
+@pytest.fixture
+def rest_handler(agent_card, mock_core_handler):
+    handler = REST03Handler(request_handler=mock_core_handler)
+    # Mock the internal handler03 for easier testing of translations
+    handler.handler03 = AsyncMock()
+    return handler
+
+
+@pytest.fixture
+def mock_context():
+    m = MagicMock(spec=ServerCallContext)
+    m.state = {'headers': {'A2A-Version': '0.3'}}
+    return m
+
+
+@pytest.fixture
+def mock_request():
+    req = MagicMock()
+    req.path_params = {}
+    req.query_params = {}
+    return req
+
+
+@pytest.mark.anyio
+async def test_on_message_send(rest_handler, mock_request, mock_context):
+    request_body = {
+        'request': {
+            'messageId': 'msg-1',
+            'role': 'ROLE_USER',
+            'content': [{'text': 'Hello'}],
+        }
+    }
+    mock_request.body = AsyncMock(
+        return_value=json.dumps(request_body).encode('utf-8')
+    )
+
+    # Configure handler03 to return a types_v03.Message
+    rest_handler.handler03.on_message_send.return_value = types_v03.Message(
+        message_id='msg-2', role='agent', parts=[types_v03.TextPart(text='Hi')]
+    )
+
+    result = await rest_handler.on_message_send(mock_request, mock_context)
+
+    assert result == {
+        'message': {
+            'messageId': 'msg-2',
+            'role': 'ROLE_AGENT',
+            'content': [{'text': 'Hi'}],
+        }
+    }
+
+    rest_handler.handler03.on_message_send.assert_called_once()
+    called_req = rest_handler.handler03.on_message_send.call_args[0][0]
+    assert isinstance(called_req, types_v03.SendMessageRequest)
+    assert called_req.params.message.message_id == 'msg-1'
+
+
+@pytest.mark.anyio
+async def test_on_message_send_stream(rest_handler, mock_request, mock_context):
+    request_body = {
+        'request': {
+            'messageId': 'msg-1',
+            'role': 'ROLE_USER',
+            'content': [{'text': 'Hello'}],
+        }
+    }
+    mock_request.body = AsyncMock(
+        return_value=json.dumps(request_body).encode('utf-8')
+    )
+
+    async def mock_stream(*args, **kwargs):
+        yield types_v03.SendStreamingMessageSuccessResponse(
+            id='req-1',
+            result=types_v03.Message(
+                message_id='msg-2',
+                role='agent',
+                parts=[types_v03.TextPart(text='Chunk')],
+            ),
+        )
+
+    rest_handler.handler03.on_message_send_stream = MagicMock(
+        side_effect=mock_stream
+    )
+
+    results = [
+        chunk
+        async for chunk in rest_handler.on_message_send_stream(
+            mock_request, mock_context
+        )
+    ]
+
+    assert results == [
+        {
+            'message': {
+                'messageId': 'msg-2',
+                'role': 'ROLE_AGENT',
+                'content': [{'text': 'Chunk'}],
+            }
+        }
+    ]
+
+
+@pytest.mark.anyio
+async def test_on_cancel_task(rest_handler, mock_request, mock_context):
+    mock_request.path_params = {'id': 'task-1'}
+
+    rest_handler.handler03.on_cancel_task.return_value = types_v03.Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=types_v03.TaskStatus(state='canceled'),
+    )
+
+    result = await rest_handler.on_cancel_task(mock_request, mock_context)
+
+    assert result == {
+        'id': 'task-1',
+        'contextId': 'ctx-1',
+        'status': {'state': 'TASK_STATE_CANCELLED'},
+    }
+
+    rest_handler.handler03.on_cancel_task.assert_called_once()
+    called_req = rest_handler.handler03.on_cancel_task.call_args[0][0]
+    assert called_req.params.id == 'task-1'
+
+
+@pytest.mark.anyio
+async def test_on_subscribe_to_task(rest_handler, mock_request, mock_context):
+    mock_request.path_params = {'id': 'task-1'}
+
+    async def mock_stream(*args, **kwargs):
+        yield types_v03.SendStreamingMessageSuccessResponse(
+            id='req-1',
+            result=types_v03.Message(
+                message_id='msg-2',
+                role='agent',
+                parts=[types_v03.TextPart(text='Update')],
+            ),
+        )
+
+    rest_handler.handler03.on_subscribe_to_task = MagicMock(
+        side_effect=mock_stream
+    )
+
+    results = [
+        chunk
+        async for chunk in rest_handler.on_subscribe_to_task(
+            mock_request, mock_context
+        )
+    ]
+
+    assert results == [
+        {
+            'message': {
+                'messageId': 'msg-2',
+                'role': 'ROLE_AGENT',
+                'content': [{'text': 'Update'}],
+            }
+        }
+    ]
+
+
+@pytest.mark.anyio
+async def test_on_subscribe_to_task_post(
+    rest_handler, mock_request, mock_context
+):
+    mock_request.path_params = {'id': 'task-1'}
+    mock_request.method = 'POST'
+    request_body = {'name': 'tasks/task-1'}
+    mock_request.body = AsyncMock(
+        return_value=json.dumps(request_body).encode('utf-8')
+    )
+
+    async def mock_stream(*args, **kwargs):
+        yield types_v03.SendStreamingMessageSuccessResponse(
+            id='req-1',
+            result=types_v03.Message(
+                message_id='msg-2',
+                role='agent',
+                parts=[types_v03.TextPart(text='Update')],
+            ),
+        )
+
+    rest_handler.handler03.on_subscribe_to_task = MagicMock(
+        side_effect=mock_stream
+    )
+
+    results = [
+        chunk
+        async for chunk in rest_handler.on_subscribe_to_task(
+            mock_request, mock_context
+        )
+    ]
+
+    assert len(results) == 1
+    rest_handler.handler03.on_subscribe_to_task.assert_called_once()
+    called_req = rest_handler.handler03.on_subscribe_to_task.call_args[0][0]
+    assert called_req.params.id == 'task-1'
+
+
+@pytest.mark.anyio
+async def test_get_push_notification(rest_handler, mock_request, mock_context):
+    mock_request.path_params = {'id': 'task-1', 'push_id': 'push-1'}
+
+    rest_handler.handler03.on_get_task_push_notification_config.return_value = (
+        types_v03.TaskPushNotificationConfig(
+            task_id='task-1',
+            push_notification_config=types_v03.PushNotificationConfig(
+                id='push-1', url='http://example.com'
+            ),
+        )
+    )
+
+    result = await rest_handler.get_push_notification(
+        mock_request, mock_context
+    )
+
+    assert result == {
+        'name': 'tasks/task-1/pushNotificationConfigs/push-1',
+        'pushNotificationConfig': {
+            'id': 'push-1',
+            'url': 'http://example.com',
+        },
+    }
+
+
+@pytest.mark.anyio
+async def test_set_push_notification(rest_handler, mock_request, mock_context):
+    mock_request.path_params = {'id': 'task-1'}
+    request_body = {
+        'parent': 'tasks/task-1',
+        'config': {'pushNotificationConfig': {'url': 'http://example.com'}},
+    }
+    mock_request.body = AsyncMock(
+        return_value=json.dumps(request_body).encode('utf-8')
+    )
+
+    rest_handler.handler03.on_create_task_push_notification_config.return_value = types_v03.TaskPushNotificationConfig(
+        task_id='task-1',
+        push_notification_config=types_v03.PushNotificationConfig(
+            id='push-1', url='http://example.com'
+        ),
+    )
+
+    result = await rest_handler.set_push_notification(
+        mock_request, mock_context
+    )
+
+    assert result == {
+        'name': 'tasks/task-1/pushNotificationConfigs/push-1',
+        'pushNotificationConfig': {
+            'id': 'push-1',
+            'url': 'http://example.com',
+        },
+    }
+
+    rest_handler.handler03.on_create_task_push_notification_config.assert_called_once()
+    called_req = rest_handler.handler03.on_create_task_push_notification_config.call_args[
+        0
+    ][0]
+    assert called_req.params.task_id == 'task-1'
+    assert (
+        called_req.params.push_notification_config.url == 'http://example.com'
+    )
+
+
+@pytest.mark.anyio
+async def test_on_get_task(rest_handler, mock_request, mock_context):
+    mock_request.path_params = {'id': 'task-1'}
+    mock_request.query_params = {'historyLength': '5'}
+
+    rest_handler.handler03.on_get_task.return_value = types_v03.Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=types_v03.TaskStatus(state='working'),
+    )
+
+    result = await rest_handler.on_get_task(mock_request, mock_context)
+
+    assert result == {
+        'id': 'task-1',
+        'contextId': 'ctx-1',
+        'status': {'state': 'TASK_STATE_WORKING'},
+    }
+
+    rest_handler.handler03.on_get_task.assert_called_once()
+    called_req = rest_handler.handler03.on_get_task.call_args[0][0]
+    assert called_req.params.id == 'task-1'
+    assert called_req.params.history_length == 5
+
+
+@pytest.mark.anyio
+async def test_on_get_task_non_integer_history_length(
+    rest_handler, mock_request, mock_context
+):
+    mock_request.path_params = {'id': 'task-1'}
+    mock_request.query_params = {'historyLength': 'abc'}
+
+    with pytest.raises(InvalidParamsError):
+        await rest_handler.on_get_task(mock_request, mock_context)
+
+    rest_handler.handler03.on_get_task.assert_not_called()
+
+
+@pytest.mark.anyio
+async def test_list_push_notifications(
+    rest_handler, mock_request, mock_context
+):
+    mock_request.path_params = {'id': 'task-1'}
+    rest_handler.handler03.on_list_task_push_notification_configs = AsyncMock(
+        return_value=[
+            types_v03.TaskPushNotificationConfig(
+                task_id='task-1',
+                push_notification_config=types_v03.PushNotificationConfig(
+                    id='push-1',
+                    url='http://example.com/notify',
+                ),
+            )
+        ]
+    )
+
+    result = await rest_handler.list_push_notifications(
+        mock_request, mock_context
+    )
+
+    assert result == {
+        'configs': [
+            {
+                'name': 'tasks/task-1/pushNotificationConfigs/push-1',
+                'pushNotificationConfig': {
+                    'id': 'push-1',
+                    'url': 'http://example.com/notify',
+                },
+            }
+        ]
+    }
+
+    rest_handler.handler03.on_list_task_push_notification_configs.assert_called_once()
+    called_req = (
+        rest_handler.handler03.on_list_task_push_notification_configs.call_args[
+            0
+        ][0]
+    )
+    assert called_req.params.id == 'task-1'
+
+
+@pytest.mark.anyio
+async def test_delete_push_notification(
+    rest_handler, mock_request, mock_context
+):
+    mock_request.path_params = {'id': 'task-1', 'push_id': 'push-1'}
+    rest_handler.handler03.on_delete_task_push_notification_config.return_value = None
+
+    result = await rest_handler.delete_push_notification(
+        mock_request, mock_context
+    )
+
+    assert result == {}
+    rest_handler.handler03.on_delete_task_push_notification_config.assert_called_once()
+    called_req = rest_handler.handler03.on_delete_task_push_notification_config.call_args[
+        0
+    ][0]
+    assert called_req.params.id == 'task-1'
+    assert called_req.params.push_notification_config_id == 'push-1'
+
+
+# Add our new translation method test
+@pytest.mark.anyio
+async def test_on_get_extended_agent_card_success(
+    rest_handler, mock_request, mock_context
+):
+    rest_handler.handler03.on_get_extended_agent_card.return_value = (
+        types_v03.AgentCard(
+            name='Extended Agent',
+            description='An extended test agent',
+            version='1.0.0',
+            url='http://jsonrpc.v03.com',
+            preferred_transport='JSONRPC',
+            protocol_version='0.3',
+            default_input_modes=[],
+            default_output_modes=[],
+            skills=[],
+            capabilities=types_v03.AgentCapabilities(
+                streaming=True,
+                push_notifications=True,
+            ),
+        )
+    )
+
+    result = await rest_handler.on_get_extended_agent_card(
+        mock_request, mock_context
+    )
+
+    # on_get_extended_agent_card returns a JSON-friendly dict via model_dump
+    assert isinstance(result, dict)
+    assert result['name'] == 'Extended Agent'
+    assert result['capabilities']['streaming'] is True
+    assert result['capabilities']['pushNotifications'] is True
+
+    rest_handler.handler03.on_get_extended_agent_card.assert_called_once()
diff --git a/tests/compat/v0_3/test_rest_routes_compat.py b/tests/compat/v0_3/test_rest_routes_compat.py
new file mode 100644
index 000000000..fbeacb1cf
--- /dev/null
+++ b/tests/compat/v0_3/test_rest_routes_compat.py
@@ -0,0 +1,428 @@
+import json
+import logging
+
+from collections.abc import AsyncIterator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2, rest_adapter
+from a2a.compat.v0_3.rest_adapter import REST03Adapter
+from a2a.compat.v0_3.rest_transport import CompatRestTransport
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import create_agent_card_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.types.a2a_pb2 import (
+    AgentCard,
+    DeleteTaskPushNotificationConfigRequest,
+    Message as Message10,
+    Part as Part10,
+    Role as Role10,
+    Task as Task10,
+    TaskState as TaskState10,
+    TaskStatus as TaskStatus10,
+)
+from a2a.utils.errors import TaskNotFoundError
+from fastapi import FastAPI
+from google.protobuf import json_format
+from httpx import ASGITransport, AsyncClient
+from starlette.applications import Starlette
+from starlette.datastructures import Headers
+from starlette.requests import Request
+
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.anyio
+async def test_shutdown_grace_period_is_passed_to_event_source_response(
+    request_handler: RequestHandler,
+) -> None:
+    async def stream(
+        request: Request, context: object
+    ) -> AsyncIterator[dict[str, str]]:
+        yield {'result': 'value'}
+
+    adapter = REST03Adapter(
+        http_handler=request_handler,
+        shutdown_grace_period=30.0,
+    )
+    mock_req = MagicMock(spec=Request)
+    mock_req.body = AsyncMock(return_value=b'{}')
+    mock_req.headers = Headers({'a2a-version': '0.3'})
+    mock_req.user = MagicMock(is_authenticated=False)
+    mock_req.auth = None
+    mock_req.scope = {}
+
+    with patch.object(
+        rest_adapter, 'create_event_source_response'
+    ) as response_class:
+        await adapter._handle_streaming_request(stream, mock_req)
+
+    response_class.assert_called_once()
+    assert response_class.call_args.kwargs['shutdown_grace_period'] == 30.0
+
+
+@pytest.fixture
+async def agent_card() -> AgentCard:
+    mock_agent_card = MagicMock(spec=AgentCard)
+    mock_agent_card.url = 'http://mockurl.com'
+
+    # Mock the capabilities object with streaming disabled
+    mock_capabilities = MagicMock()
+    mock_capabilities.streaming = False
+    mock_capabilities.push_notifications = True
+    mock_capabilities.extended_agent_card = True
+    mock_agent_card.capabilities = mock_capabilities
+
+    return mock_agent_card
+
+
+@pytest.fixture
+async def request_handler() -> RequestHandler:
+    return MagicMock(spec=RequestHandler)
+
+
+@pytest.fixture
+async def app(
+    agent_card: AgentCard,
+    request_handler: RequestHandler,
+) -> Starlette:
+    """Builds the Starlette application for testing."""
+    request_handler._agent_card = agent_card
+    rest_routes = create_rest_routes(
+        request_handler=request_handler, enable_v0_3_compat=True
+    )
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/well-known/agent.json'
+    )
+    return Starlette(routes=rest_routes + agent_card_routes)
+
+
+@pytest.fixture
+async def client(app: FastAPI) -> AsyncClient:
+    return AsyncClient(
+        transport=ASGITransport(app=app), base_url='http://testapp'
+    )
+
+
+@pytest.mark.anyio
+async def test_send_message_success_message_v03(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    expected_response = a2a_v0_3_pb2.SendMessageResponse(
+        msg=a2a_v0_3_pb2.Message(
+            message_id='test',
+            role=a2a_v0_3_pb2.Role.ROLE_AGENT,
+            content=[a2a_v0_3_pb2.Part(text='response message')],
+        ),
+    )
+    request_handler.on_message_send.return_value = Message10(
+        message_id='test',
+        role=Role10.ROLE_AGENT,
+        parts=[Part10(text='response message')],
+    )
+
+    request = a2a_v0_3_pb2.SendMessageRequest(
+        request=a2a_v0_3_pb2.Message(
+            message_id='req',
+            role=a2a_v0_3_pb2.Role.ROLE_USER,
+            content=[a2a_v0_3_pb2.Part(text='hello')],
+        ),
+    )
+
+    response = await client.post(
+        '/v1/message:send', json=json_format.MessageToDict(request)
+    )
+    response.raise_for_status()
+
+    actual_response = a2a_v0_3_pb2.SendMessageResponse()
+    json_format.Parse(response.text, actual_response)
+    assert expected_response == actual_response
+
+
+@pytest.mark.anyio
+async def test_send_message_success_task_v03(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    expected_response = a2a_v0_3_pb2.SendMessageResponse(
+        task=a2a_v0_3_pb2.Task(
+            id='test_task_id',
+            context_id='test_context_id',
+            status=a2a_v0_3_pb2.TaskStatus(
+                state=a2a_v0_3_pb2.TaskState.TASK_STATE_COMPLETED,
+            ),
+        ),
+    )
+    request_handler.on_message_send.return_value = Task10(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=TaskStatus10(
+            state=TaskState10.TASK_STATE_COMPLETED,
+        ),
+    )
+
+    request = a2a_v0_3_pb2.SendMessageRequest(
+        request=a2a_v0_3_pb2.Message(),
+    )
+
+    response = await client.post(
+        '/v1/message:send', json=json_format.MessageToDict(request)
+    )
+    response.raise_for_status()
+
+    actual_response = a2a_v0_3_pb2.SendMessageResponse()
+    json_format.Parse(response.text, actual_response)
+    assert expected_response == actual_response
+
+
+@pytest.mark.anyio
+async def test_get_task_v03(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    expected_response = a2a_v0_3_pb2.Task(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=a2a_v0_3_pb2.TaskStatus(
+            state=a2a_v0_3_pb2.TaskState.TASK_STATE_COMPLETED,
+        ),
+    )
+    request_handler.on_get_task.return_value = Task10(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=TaskStatus10(
+            state=TaskState10.TASK_STATE_COMPLETED,
+        ),
+    )
+
+    response = await client.get('/v1/tasks/test_task_id')
+    response.raise_for_status()
+
+    actual_response = a2a_v0_3_pb2.Task()
+    json_format.Parse(response.text, actual_response)
+    assert expected_response == actual_response
+
+
+@pytest.mark.anyio
+async def test_get_task_v03_non_integer_history_length(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    response = await client.get('/v1/tasks/test_task_id?historyLength=abc')
+
+    assert response.status_code == 400
+    assert response.json()['error']['status'] == 'INVALID_ARGUMENT'
+    request_handler.on_get_task.assert_not_called()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    'path',
+    ['/v1/message:send', '/v1/tasks/test_task_id/pushNotificationConfigs'],
+)
+async def test_invalid_utf8_body_v03_is_bad_request(
+    client: AsyncClient, path: str
+) -> None:
+    response = await client.post(
+        path, content=b'{"message": {"messageId": "\xff"}}'
+    )
+
+    assert response.status_code == 400
+    assert response.json()['error']['status'] == 'INVALID_ARGUMENT'
+
+
+@pytest.mark.anyio
+async def test_delete_push_notification_config_v03(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    request_handler.on_delete_task_push_notification_config.return_value = None
+
+    response = await client.delete(
+        '/v1/tasks/test_task_id/pushNotificationConfigs/push-1'
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {}
+    request_handler.on_delete_task_push_notification_config.assert_awaited_once()
+    params = request_handler.on_delete_task_push_notification_config.call_args[
+        0
+    ][0]
+    assert params == DeleteTaskPushNotificationConfigRequest(
+        task_id='test_task_id', id='push-1'
+    )
+
+
+@pytest.mark.anyio
+async def test_delete_push_notification_config_v03_unknown_task_returns_404(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    request_handler.on_delete_task_push_notification_config.side_effect = (
+        TaskNotFoundError
+    )
+
+    response = await client.delete(
+        '/v1/tasks/unknown/pushNotificationConfigs/push-1'
+    )
+
+    assert response.status_code == 404
+    assert response.json()['error']['status'] == 'NOT_FOUND'
+
+
+@pytest.mark.anyio
+async def test_compat_rest_client_deletes_push_notification_config(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    request_handler.on_delete_task_push_notification_config.return_value = None
+    transport = CompatRestTransport(
+        httpx_client=client,
+        agent_card=AgentCard(),
+        url='http://testapp',
+    )
+
+    await transport.delete_task_push_notification_config(
+        DeleteTaskPushNotificationConfigRequest(
+            task_id='test_task_id', id='push-1'
+        )
+    )
+
+    request_handler.on_delete_task_push_notification_config.assert_awaited_once()
+    params = request_handler.on_delete_task_push_notification_config.call_args[
+        0
+    ][0]
+    assert params == DeleteTaskPushNotificationConfigRequest(
+        task_id='test_task_id', id='push-1'
+    )
+
+
+@pytest.mark.anyio
+async def test_list_tasks_not_in_v03_adapter_routes(
+    request_handler: RequestHandler,
+) -> None:
+    adapter = REST03Adapter(http_handler=request_handler)
+    assert ('/v1/tasks', 'GET') not in adapter.routes()
+
+
+@pytest.mark.anyio
+async def test_cancel_task_v03(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    expected_response = a2a_v0_3_pb2.Task(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=a2a_v0_3_pb2.TaskStatus(
+            state=a2a_v0_3_pb2.TaskState.TASK_STATE_CANCELLED,
+        ),
+    )
+    request_handler.on_cancel_task.return_value = Task10(
+        id='test_task_id',
+        context_id='test_context_id',
+        status=TaskStatus10(
+            state=TaskState10.TASK_STATE_CANCELED,
+        ),
+    )
+
+    response = await client.post('/v1/tasks/test_task_id:cancel')
+    response.raise_for_status()
+
+    actual_response = a2a_v0_3_pb2.Task()
+    json_format.Parse(response.text, actual_response)
+    assert expected_response == actual_response
+
+
+@pytest.mark.anyio
+async def test_v03_streaming_does_not_ascii_escape_non_ascii(
+    request_handler: RequestHandler,
+) -> None:
+    """v0.3 REST streaming must emit raw UTF-8 for non-ASCII characters.
+
+    Regression test for https://github.com/a2aproject/a2a-python/issues/1078.
+    """
+    adapter = REST03Adapter(http_handler=request_handler)
+    non_ascii_text = '你好'
+
+    async def stream_with_non_ascii(
+        request: Request, context: object
+    ) -> AsyncIterator[dict]:
+        yield {'msg': {'text': non_ascii_text}}
+
+    mock_req = MagicMock(spec=Request)
+    mock_req.body = AsyncMock(return_value=b'{}')
+    mock_req.headers = Headers({'a2a-version': '0.3'})
+    mock_req.user = MagicMock(is_authenticated=False)
+    mock_req.auth = None
+    mock_req.scope = {}
+
+    response = await adapter._handle_streaming_request(
+        stream_with_non_ascii, mock_req
+    )
+    chunks = []
+    async for chunk in response.body_iterator:
+        chunks.append(chunk)
+
+    assert len(chunks) == 1
+    chunk = chunks[0]
+    payload = getattr(chunk, 'data', chunk)
+    if isinstance(payload, bytes):
+        payload = payload.decode('utf-8')
+    assert non_ascii_text in payload
+    assert '\\u4f60\\u597d' not in payload
+
+
+@pytest.mark.anyio
+async def test_v03_message_stream_malformed_json_returns_400(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    response = await client.post(
+        '/v1/message:stream',
+        content=b'{bad',
+        headers={'Content-Type': 'application/json'},
+    )
+
+    assert response.status_code == 400
+    assert response.headers['content-type'].startswith('application/json')
+    assert response.json()['error']['status'] == 'INVALID_ARGUMENT'
+    request_handler.on_message_send_stream.assert_not_called()
+
+
+@pytest.mark.anyio
+async def test_v03_subscribe_unknown_task_returns_404(
+    client: AsyncClient, request_handler: MagicMock
+) -> None:
+    async def not_found(*args: object, **kwargs: object) -> AsyncIterator[None]:
+        raise TaskNotFoundError
+        yield
+
+    request_handler.on_subscribe_to_task.side_effect = not_found
+
+    response = await client.post('/v1/tasks/unknown:subscribe')
+
+    assert response.status_code == 404
+    assert response.json()['error']['status'] == 'NOT_FOUND'
+
+
+@pytest.mark.anyio
+async def test_v03_streaming_yields_all_events_in_order(
+    request_handler: RequestHandler,
+) -> None:
+    adapter = REST03Adapter(http_handler=request_handler)
+
+    async def stream(
+        request: Request, context: object
+    ) -> AsyncIterator[dict[str, int]]:
+        for i in range(3):
+            yield {'n': i}
+
+    mock_req = MagicMock(spec=Request)
+    mock_req.body = AsyncMock(return_value=b'{}')
+    mock_req.headers = Headers({'a2a-version': '0.3'})
+    mock_req.user = MagicMock(is_authenticated=False)
+    mock_req.auth = None
+    mock_req.scope = {}
+
+    response = await adapter._handle_streaming_request(stream, mock_req)
+    chunks = [chunk async for chunk in response.body_iterator]
+
+    assert [json.loads(chunk) for chunk in chunks] == [
+        {'n': 0},
+        {'n': 1},
+        {'n': 2},
+    ]
diff --git a/tests/compat/v0_3/test_rest_transport.py b/tests/compat/v0_3/test_rest_transport.py
new file mode 100644
index 000000000..551d39c35
--- /dev/null
+++ b/tests/compat/v0_3/test_rest_transport.py
@@ -0,0 +1,987 @@
+import json
+
+from collections.abc import AsyncGenerator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.client.errors import A2AClientError
+from a2a.compat.v0_3 import types as types_v03
+from a2a.compat.v0_3.rest_transport import CompatRestTransport
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_rest_routes
+from a2a.server.tasks import (
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    Message,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SendMessageResponse,
+    StreamResponse,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+from a2a.utils.errors import InvalidParamsError, MethodNotFoundError
+from starlette.applications import Starlette
+
+
+@pytest.fixture
+def mock_httpx_client():
+    client = AsyncMock(spec=httpx.AsyncClient)
+    client.is_closed = False
+    return client
+
+
+@pytest.fixture
+def agent_card():
+    return AgentCard(capabilities=AgentCapabilities(extended_agent_card=True))
+
+
+@pytest.fixture
+def transport(mock_httpx_client, agent_card):
+    return CompatRestTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=agent_card,
+        url='http://example.com',
+    )
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_response_msg_parsing(
+    transport,
+):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.json.return_value = {
+        'msg': {'messageId': 'msg-123', 'role': 'agent'}
+    }
+
+    async def mock_send_request(*args, **kwargs):
+        return mock_response.json()
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+
+    expected_response = SendMessageResponse(
+        message=Message(message_id='msg-123', role=Role.ROLE_AGENT)
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_task(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.json.return_value = {'task': {'id': 'task-123'}}
+
+    async def mock_send_request(*args, **kwargs):
+        return mock_response.json()
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+
+    expected_response = SendMessageResponse(
+        task=Task(id='task-123', status=Task(id='task-123').status)
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_task(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {'id': 'task-123'}
+
+    transport._send_request = mock_send_request
+
+    req = GetTaskRequest(id='task-123')
+    response = await transport.get_task(req)
+
+    expected_response = Task(id='task-123', status=TaskStatus())
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_cancel_task(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {'id': 'task-123'}
+
+    transport._send_request = mock_send_request
+
+    req = CancelTaskRequest(id='task-123')
+    response = await transport.cancel_task(req)
+
+    expected_response = Task(id='task-123', status=TaskStatus())
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_create_task_push_notification_config(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+            'pushNotificationConfig': {'url': 'http://push', 'id': 'push-123'},
+        }
+
+    transport._send_request = mock_send_request
+
+    req = TaskPushNotificationConfig(
+        task_id='task-123', id='push-123', url='http://push'
+    )
+    response = await transport.create_task_push_notification_config(req)
+
+    expected_response = TaskPushNotificationConfig(
+        id='push-123', task_id='task-123', url='http://push'
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_task_push_notification_config(
+    transport,
+):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+            'pushNotificationConfig': {'url': 'http://push', 'id': 'push-123'},
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetTaskPushNotificationConfigRequest(
+        task_id='task-123', id='push-123'
+    )
+    response = await transport.get_task_push_notification_config(req)
+
+    expected_response = TaskPushNotificationConfig(
+        id='push-123', task_id='task-123', url='http://push'
+    )
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_extended_agent_card(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {
+            'name': 'ExtendedAgent',
+            'capabilities': {},
+            'supportsAuthenticatedExtendedCard': True,
+        }
+
+    transport._send_request = mock_send_request
+
+    req = GetExtendedAgentCardRequest()
+    response = await transport.get_extended_agent_card(req)
+
+    assert response.name == 'ExtendedAgent'
+    assert response.capabilities.extended_agent_card is True
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_extended_agent_card_keeps_security(
+    transport,
+):
+    """v0.3 servers send the card as JSON, not as the v0.3 proto."""
+    card = types_v03.AgentCard(
+        name='ExtendedAgent',
+        description='Extended',
+        version='1.0.0',
+        url='http://example.com',
+        capabilities=types_v03.AgentCapabilities(),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            types_v03.AgentSkill(
+                id='skill-1',
+                name='Skill',
+                description='Skill',
+                tags=['tag'],
+                security=[{'bearer': []}],
+            )
+        ],
+        security_schemes={
+            'bearer': types_v03.SecurityScheme(
+                root=types_v03.HTTPAuthSecurityScheme(scheme='bearer')
+            )
+        },
+        security=[{'bearer': []}],
+        supports_authenticated_extended_card=True,
+    )
+
+    async def mock_send_request(*args, **kwargs):
+        # Same serialization as REST03Handler.on_get_extended_agent_card.
+        return card.model_dump(mode='json', exclude_none=True)
+
+    transport._send_request = mock_send_request
+
+    response = await transport.get_extended_agent_card(
+        GetExtendedAgentCardRequest()
+    )
+
+    scheme = response.security_schemes['bearer']
+    assert scheme.WhichOneof('scheme') == 'http_auth_security_scheme'
+    assert scheme.http_auth_security_scheme.scheme == 'bearer'
+    assert list(response.security_requirements[0].schemes) == ['bearer']
+    assert list(response.skills[0].security_requirements[0].schemes) == [
+        'bearer'
+    ]
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_extended_agent_card_not_supported(
+    transport,
+):
+    transport.agent_card.capabilities.extended_agent_card = False
+
+    req = GetExtendedAgentCardRequest()
+    response = await transport.get_extended_agent_card(req)
+
+    assert response == transport.agent_card
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_close(transport, mock_httpx_client):
+    await transport.close()
+    mock_httpx_client.aclose.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_streaming(transport):
+    async def mock_send_stream_request(*args, **kwargs):
+        task = Task(id='task-123')
+        task.status.message.role = Role.ROLE_AGENT
+        yield StreamResponse(task=task)
+        yield StreamResponse(message=Message(message_id='msg-123'))
+
+    transport._send_stream_request = mock_send_stream_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    events = [event async for event in transport.send_message_streaming(req)]
+
+    assert len(events) == 2
+    expected_task = Task(id='task-123')
+    expected_task.status.message.role = Role.ROLE_AGENT
+    assert events[0] == StreamResponse(task=expected_task)
+    assert events[1] == StreamResponse(message=Message(message_id='msg-123'))
+
+
+def create_405_error():
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 405
+    mock_response.json.return_value = {
+        'type': 'MethodNotAllowed',
+        'message': 'Method Not Allowed',
+    }
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com/v1/tasks/task-123:subscribe'
+
+    status_error = httpx.HTTPStatusError(
+        '405 Method Not Allowed', request=mock_request, response=mock_response
+    )
+    raise A2AClientError('HTTP Error 405') from status_error
+
+
+def create_500_error():
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 500
+    mock_response.json.return_value = {
+        'type': 'InternalError',
+        'message': 'Internal Error',
+    }
+    mock_request = MagicMock(spec=httpx.Request)
+
+    status_error = httpx.HTTPStatusError(
+        '500 Internal Error', request=mock_request, response=mock_response
+    )
+    raise A2AClientError('HTTP Error 500') from status_error
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_post_works_no_retry(transport):
+    """Scenario: POST works, no retry."""
+
+    async def mock_stream(method, path, context=None, json=None):
+        assert method == 'POST'
+        assert json is None
+        task = Task(id='task-123')
+        task.status.message.role = Role.ROLE_AGENT
+        yield StreamResponse(task=task)
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    events = [event async for event in transport.subscribe(req)]
+
+    assert len(events) == 1
+    expected_task = Task(id='task-123')
+    expected_task.status.message.role = Role.ROLE_AGENT
+    assert events[0] == StreamResponse(task=expected_task)
+    assert transport._subscribe_method_override is None
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_post_405_retry_get_success(
+    transport,
+):
+    """Scenario: POST returns 405, automatic retry GET. Second call uses GET directly."""
+    call_count = 0
+
+    async def mock_stream(method, path, context=None, json=None):
+        nonlocal call_count
+        call_count += 1
+        if method == 'POST':
+            assert json is None
+            create_405_error()
+        if method == 'GET':
+            assert json is None
+            task = Task(id='task-123')
+            task.status.message.role = Role.ROLE_AGENT
+            yield StreamResponse(task=task)
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    events = [event async for event in transport.subscribe(req)]
+
+    assert len(events) == 1
+    assert call_count == 2
+    assert transport._subscribe_method_override == 'GET'
+
+    # Second call should use GET directly
+    call_count = 0
+    events = [event async for event in transport.subscribe(req)]
+    assert len(events) == 1
+    assert call_count == 1  # Only GET called
+    assert transport._subscribe_method_override == 'GET'
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_post_405_get_405_fails(
+    transport,
+):
+    """Scenario: POST return 405, retry GET, return 405 - error. Second call is just POST."""
+
+    method_count = {}
+
+    async def mock_stream(method, path, context=None, json=None):
+        method_count[method] = method_count.get(method, 0) + 1
+        if method in {'POST', 'GET'}:
+            assert json is None
+        # To make it an async generator even when it raises
+        if False:
+            yield
+        create_405_error()
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    with pytest.raises(A2AClientError) as exc_info:
+        [event async for event in transport.subscribe(req)]
+
+    assert '405' in str(exc_info.value)
+    assert transport._subscribe_method_override == 'POST'
+    assert method_count == {'POST': 1, 'GET': 1}
+    assert transport._subscribe_auto_method_override is False
+
+    # Second call should try POST directly and fail without retry
+    with pytest.raises(A2AClientError):
+        [event async for event in transport.subscribe(req)]
+    assert transport._subscribe_auto_method_override is False
+    assert transport._subscribe_method_override == 'POST'
+    assert method_count == {'POST': 2, 'GET': 1}
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_post_500_no_retry(transport):
+    """Scenario: POST return 500, no automatic retry."""
+    call_count = 0
+
+    async def mock_stream(method, path, context=None, json=None):
+        nonlocal call_count
+        call_count += 1
+        assert method == 'POST'
+        assert json is None
+        if False:
+            yield
+        create_500_error()
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    with pytest.raises(A2AClientError) as exc_info:
+        [event async for event in transport.subscribe(req)]
+
+    assert '500' in str(exc_info.value)
+    assert call_count == 1  # No retry on 500
+    assert transport._subscribe_method_override is None
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_method_override_avoids_retry_get(
+    mock_httpx_client, agent_card
+):
+    """Scenario: Init with GET override, server returns 405, no automatic retry."""
+    transport = CompatRestTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=agent_card,
+        url='http://example.com',
+        subscribe_method_override='GET',
+    )
+    call_count = 0
+
+    async def mock_stream(method, path, context=None, json=None):
+        nonlocal call_count
+        call_count += 1
+        assert method == 'GET'
+        assert json is None
+        if False:
+            yield
+        create_405_error()
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    with pytest.raises(A2AClientError) as exc_info:
+        [event async for event in transport.subscribe(req)]
+
+    assert '405' in str(exc_info.value)
+    assert call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_subscribe_method_override_avoids_retry_post(
+    mock_httpx_client, agent_card
+):
+    """Scenario: Init with POST override, server returns 405, no automatic retry."""
+    transport = CompatRestTransport(
+        httpx_client=mock_httpx_client,
+        agent_card=agent_card,
+        url='http://example.com',
+        subscribe_method_override='POST',
+    )
+    call_count = 0
+
+    async def mock_stream(method, path, context=None, json=None):
+        nonlocal call_count
+        call_count += 1
+        assert method == 'POST'
+        assert json is None
+        if False:
+            yield
+        create_405_error()
+
+    transport._send_stream_request = mock_stream
+
+    req = SubscribeToTaskRequest(id='task-123')
+    with pytest.raises(A2AClientError) as exc_info:
+        [event async for event in transport.subscribe(req)]
+
+    assert '405' in str(exc_info.value)
+    assert call_count == 1
+
+
+def test_compat_rest_transport_handle_http_error(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 400
+    mock_response.json.return_value = {
+        'type': 'InvalidParamsError',
+        'message': 'Invalid parameters',
+    }
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        transport._handle_http_error(error)
+
+    assert str(exc_info.value) == 'Invalid parameters'
+
+
+def test_compat_rest_transport_handle_http_error_not_found(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 404
+    mock_response.json.side_effect = json.JSONDecodeError('msg', 'doc', 0)
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(MethodNotFoundError):
+        transport._handle_http_error(error)
+
+
+def test_compat_rest_transport_handle_http_error_generic(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 500
+    mock_response.json.side_effect = json.JSONDecodeError('msg', 'doc', 0)
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(A2AClientError):
+        transport._handle_http_error(error)
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_list_tasks(transport):
+    with pytest.raises(NotImplementedError):
+        await transport.list_tasks(ListTasksRequest())
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_list_task_push_notification_configs(
+    transport,
+):
+    mock_execute_request = AsyncMock(
+        return_value={
+            'configs': [
+                {
+                    'name': 'tasks/task-123/pushNotificationConfigs/push-1',
+                    'pushNotificationConfig': {
+                        'url': 'http://push-1',
+                        'id': 'push-1',
+                    },
+                },
+                {
+                    'name': 'tasks/task-123/pushNotificationConfigs/push-2',
+                    'pushNotificationConfig': {
+                        'url': 'http://push-2',
+                        'id': 'push-2',
+                    },
+                },
+            ]
+        }
+    )
+    transport._execute_request = mock_execute_request
+
+    response = await transport.list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task-123')
+    )
+
+    mock_execute_request.assert_awaited_once_with(
+        'GET', '/v1/tasks/task-123/pushNotificationConfigs', context=None
+    )
+    assert list(response.configs) == [
+        TaskPushNotificationConfig(
+            id='push-1', task_id='task-123', url='http://push-1'
+        ),
+        TaskPushNotificationConfig(
+            id='push-2', task_id='task-123', url='http://push-2'
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_delete_task_push_notification_config(
+    transport,
+):
+    mock_execute_request = AsyncMock(return_value={})
+    transport._execute_request = mock_execute_request
+
+    response = await transport.delete_task_push_notification_config(
+        DeleteTaskPushNotificationConfigRequest(
+            task_id='task-123', id='push-123'
+        )
+    )
+
+    mock_execute_request.assert_awaited_once_with(
+        'DELETE',
+        '/v1/tasks/task-123/pushNotificationConfigs/push-123',
+        context=None,
+    )
+    assert response is None
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_empty(transport):
+    async def mock_send_request(*args, **kwargs):
+        return {}
+
+    transport._send_request = mock_send_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+
+    response = await transport.send_message(req)
+    assert response == SendMessageResponse()
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_without_configuration(
+    transport,
+):
+    """No configuration is sent, so the server keeps its blocking default."""
+    sent: dict = {}
+
+    async def mock_execute_request(method, path, context=None, json=None):
+        sent.update(json)
+        return {}
+
+    transport._execute_request = mock_execute_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER)
+    )
+    await transport.send_message(req)
+
+    assert 'configuration' not in sent
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_with_configuration(
+    transport,
+):
+    sent: dict = {}
+
+    async def mock_execute_request(method, path, context=None, json=None):
+        sent.update(json)
+        return {}
+
+    transport._execute_request = mock_execute_request
+
+    req = SendMessageRequest(
+        message=Message(message_id='msg-1', role=Role.ROLE_USER),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+    await transport.send_message(req)
+
+    assert sent['configuration']['blocking'] is True
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_uses_json_names(transport):
+    """The v0.3 spec requires json_name keys in HTTP+JSON bodies."""
+    sent: dict = {}
+
+    async def mock_execute_request(method, path, context=None, json=None):
+        sent.update(json)
+        return {}
+
+    transport._execute_request = mock_execute_request
+
+    req = SendMessageRequest(
+        message=Message(
+            message_id='msg-1',
+            context_id='ctx-1',
+            task_id='task-1',
+            role=Role.ROLE_USER,
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+    await transport.send_message(req)
+
+    assert 'request' not in sent
+    assert sent['message']['messageId'] == 'msg-1'
+    assert sent['message']['contextId'] == 'ctx-1'
+    assert sent['message']['taskId'] == 'task-1'
+    assert sent['configuration']['acceptedOutputModes'] == ['text/plain']
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_send_message_streaming_uses_json_names(
+    transport,
+):
+    sent: dict = {}
+
+    async def mock_send_stream_request(method, path, context=None, json=None):
+        sent.update(json)
+        yield StreamResponse(message=Message(message_id='msg-123'))
+
+    transport._send_stream_request = mock_send_stream_request
+
+    req = SendMessageRequest(
+        message=Message(
+            message_id='msg-1', context_id='ctx-1', role=Role.ROLE_USER
+        )
+    )
+    _ = [event async for event in transport.send_message_streaming(req)]
+
+    assert 'request' not in sent
+    assert sent['message']['messageId'] == 'msg-1'
+    assert sent['message']['contextId'] == 'ctx-1'
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_create_task_push_notification_config_uses_json_names(
+    transport,
+):
+    sent: dict = {}
+
+    async def mock_execute_request(method, path, context=None, json=None):
+        sent.update(json)
+        return {
+            'name': 'tasks/task-123/pushNotificationConfigs/push-123',
+            'pushNotificationConfig': {'url': 'http://push', 'id': 'push-123'},
+        }
+
+    transport._execute_request = mock_execute_request
+
+    req = TaskPushNotificationConfig(
+        task_id='task-123', id='push-123', url='http://push'
+    )
+    await transport.create_task_push_notification_config(req)
+
+    assert sent['configId'] == 'push-123'
+    assert sent['config']['pushNotificationConfig']['id'] == 'push-123'
+    assert 'config_id' not in sent
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_task_no_history(transport):
+    async def mock_execute_request(method, path, context=None, params=None):
+        assert 'historyLength' not in params
+        return {'id': 'task-123'}
+
+    transport._execute_request = mock_execute_request
+
+    req = GetTaskRequest(id='task-123')
+    response = await transport.get_task(req)
+    expected_response = Task(id='task-123', status=TaskStatus())
+    assert response == expected_response
+
+
+@pytest.mark.asyncio
+async def test_compat_rest_transport_get_task_with_history(transport):
+    async def mock_execute_request(method, path, context=None, params=None):
+        assert params['historyLength'] == 10
+        return {'id': 'task-123'}
+
+    transport._execute_request = mock_execute_request
+
+    req = GetTaskRequest(id='task-123', history_length=10)
+    response = await transport.get_task(req)
+    expected_response = Task(id='task-123', status=TaskStatus())
+    assert response == expected_response
+
+
+def test_compat_rest_transport_handle_http_error_invalid_error_type(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 500
+    mock_response.json.return_value = {
+        'type': 123,
+        'message': 'Invalid parameters',
+    }
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(A2AClientError):
+        transport._handle_http_error(error)
+
+
+@pytest.mark.parametrize(
+    ('status_code', 'body', 'expected_error'),
+    [
+        (401, 'invalid_token', A2AClientError),
+        (404, ['Not Found'], MethodNotFoundError),
+        (503, None, A2AClientError),
+    ],
+)
+def test_compat_rest_transport_handle_http_error_non_object_body(
+    transport, status_code, body, expected_error
+):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = status_code
+    mock_response.json.return_value = body
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(expected_error):
+        transport._handle_http_error(error)
+
+
+def test_compat_rest_transport_handle_http_error_unknown_error_type(transport):
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 500
+    mock_response.json.return_value = {
+        'type': 'SomeUnknownErrorClass',
+        'message': 'Unknown',
+    }
+
+    mock_request = MagicMock(spec=httpx.Request)
+    mock_request.url = 'http://example.com'
+
+    error = httpx.HTTPStatusError(
+        'Error', request=mock_request, response=mock_response
+    )
+
+    with pytest.raises(A2AClientError):
+        transport._handle_http_error(error)
+
+
+@pytest.mark.asyncio
+@patch('a2a.compat.v0_3.rest_transport.send_http_stream_request')
+async def test_compat_rest_transport_send_stream_request(
+    mock_send_http_stream_request, transport
+):
+    async def mock_generator(*args, **kwargs):
+        yield b'{"task": {"id": "task-123"}}'
+
+    mock_send_http_stream_request.return_value = mock_generator()
+
+    events = [
+        event async for event in transport._send_stream_request('POST', '/test')
+    ]
+
+    assert len(events) == 1
+    expected_task = Task(id='task-123', status=TaskStatus())
+    assert events[0] == StreamResponse(task=expected_task)
+
+    mock_send_http_stream_request.assert_called_once_with(
+        transport.httpx_client,
+        'POST',
+        'http://example.com/test',
+        transport._handle_http_error,
+        json=None,
+        headers={'a2a-version': '0.3'},
+    )
+
+
+@pytest.mark.asyncio
+@patch('a2a.compat.v0_3.rest_transport.send_http_request')
+async def test_compat_rest_transport_execute_request(
+    mock_send_http_request, transport
+):
+    mock_send_http_request.return_value = {'ok': True}
+    mock_request = httpx.Request('POST', 'http://example.com')
+    transport.httpx_client.build_request.return_value = mock_request
+
+    res = await transport._execute_request(
+        'POST', '/test', json={'some': 'data'}
+    )
+    assert res == {'ok': True}
+
+    # Assert httpx client build_request was called correctly
+    transport.httpx_client.build_request.assert_called_once_with(
+        'POST',
+        'http://example.com/test',
+        json={'some': 'data'},
+        params=None,
+        headers={'a2a-version': '0.3'},
+    )
+    mock_send_http_request.assert_called_once_with(
+        transport.httpx_client, mock_request, transport._handle_http_error
+    )
+
+
+class TestCompatRestTransportPathEncoding:
+    """Ids with reserved URL characters reach their own resource.
+
+    Runs a real request handler behind the v0.3 REST routes, so a wrong path
+    reads the wrong resource.
+    """
+
+    @pytest_asyncio.fixture
+    async def transport(self) -> AsyncGenerator[CompatRestTransport, None]:
+        task_store = InMemoryTaskStore()
+        await task_store.save(
+            Task(
+                id='t1',
+                context_id='c1',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            ),
+            ServerCallContext(),
+        )
+        agent_card = AgentCard(
+            capabilities=AgentCapabilities(push_notifications=True)
+        )
+        request_handler = DefaultRequestHandler(
+            None,
+            task_store,
+            agent_card,
+            push_config_store=InMemoryPushNotificationConfigStore(),
+        )
+        app = Starlette(
+            routes=create_rest_routes(
+                request_handler=request_handler, enable_v0_3_compat=True
+            )
+        )
+        httpx_client = httpx.AsyncClient(transport=httpx.ASGITransport(app=app))
+        transport = CompatRestTransport(
+            httpx_client, agent_card, 'http://agent'
+        )
+        yield transport
+        await transport.close()
+
+    @pytest.mark.asyncio
+    async def test_get_push_config_does_not_return_config_named_by_prefix(
+        self, transport: CompatRestTransport
+    ):
+        for config_id, url in (
+            ('alerts', 'https://hooks.example.com/alerts'),
+            ('alerts#ops', 'https://hooks.example.com/ops'),
+        ):
+            await transport.create_task_push_notification_config(
+                TaskPushNotificationConfig(task_id='t1', id=config_id, url=url)
+            )
+
+        config = await transport.get_task_push_notification_config(
+            GetTaskPushNotificationConfigRequest(task_id='t1', id='alerts#ops')
+        )
+
+        assert config.id == 'alerts#ops'
+        assert config.url == 'https://hooks.example.com/ops'
+
+    @pytest.mark.asyncio
+    async def test_get_task_does_not_return_task_named_by_id_prefix(
+        self, transport: CompatRestTransport
+    ):
+        # The v0.3 client maps the server's 404 for an unknown task to
+        # MethodNotFoundError.
+        with pytest.raises(MethodNotFoundError):
+            await transport.get_task(GetTaskRequest(id='t1?x'))
diff --git a/tests/compat/v0_3/test_versions.py b/tests/compat/v0_3/test_versions.py
new file mode 100644
index 000000000..058b9ffdf
--- /dev/null
+++ b/tests/compat/v0_3/test_versions.py
@@ -0,0 +1,27 @@
+"""Tests for version utility functions."""
+
+import pytest
+
+from a2a.compat.v0_3.versions import is_legacy_version
+
+
+@pytest.mark.parametrize(
+    'version, expected',
+    [
+        ('0.3', True),
+        ('0.3.0', True),
+        ('0.9', True),
+        ('0.9.9', True),
+        ('1.0', False),
+        ('1.0.0', False),
+        ('1.1', False),
+        ('0.2', False),
+        ('0.2.9', False),
+        (None, False),
+        ('', False),
+        ('invalid', False),
+        ('v0.3', True),
+    ],
+)
+def test_is_legacy_version(version, expected):
+    assert is_legacy_version(version) == expected
diff --git a/tests/extensions/__init__.py b/tests/extensions/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/extensions/test_common.py b/tests/extensions/test_common.py
new file mode 100644
index 000000000..d9f71780f
--- /dev/null
+++ b/tests/extensions/test_common.py
@@ -0,0 +1,67 @@
+from a2a.extensions.common import (
+    find_extension_by_uri,
+    get_requested_extensions,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentExtension,
+    AgentInterface,
+)
+
+
+def test_get_requested_extensions():
+    assert get_requested_extensions([]) == set()
+    assert get_requested_extensions(['foo']) == {'foo'}
+    assert get_requested_extensions(['foo', 'bar']) == {'foo', 'bar'}
+    assert get_requested_extensions(['foo, bar']) == {'foo', 'bar'}
+    assert get_requested_extensions(['foo,bar']) == {'foo', 'bar'}
+    assert get_requested_extensions(['foo', 'bar,baz']) == {'foo', 'bar', 'baz'}
+    assert get_requested_extensions(['foo,, bar', 'baz']) == {
+        'foo',
+        'bar',
+        'baz',
+    }
+    assert get_requested_extensions([' foo , bar ', 'baz']) == {
+        'foo',
+        'bar',
+        'baz',
+    }
+
+
+def test_find_extension_by_uri():
+    ext1 = AgentExtension(uri='foo', description='The Foo extension')
+    ext2 = AgentExtension(uri='bar', description='The Bar extension')
+    card = AgentCard(
+        name='Test Agent',
+        description='Test Agent Description',
+        version='1.0',
+        supported_interfaces=[
+            AgentInterface(url='http://test.com', protocol_binding='HTTP+JSON')
+        ],
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        capabilities=AgentCapabilities(extensions=[ext1, ext2]),
+    )
+
+    assert find_extension_by_uri(card, 'foo') == ext1
+    assert find_extension_by_uri(card, 'bar') == ext2
+    assert find_extension_by_uri(card, 'baz') is None
+
+
+def test_find_extension_by_uri_no_extensions():
+    card = AgentCard(
+        name='Test Agent',
+        description='Test Agent Description',
+        version='1.0',
+        supported_interfaces=[
+            AgentInterface(url='http://test.com', protocol_binding='HTTP+JSON')
+        ],
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        capabilities=AgentCapabilities(extensions=None),
+    )
+
+    assert find_extension_by_uri(card, 'foo') is None
diff --git a/tests/helpers/test_agent_card_display.py b/tests/helpers/test_agent_card_display.py
new file mode 100644
index 000000000..0424e6d50
--- /dev/null
+++ b/tests/helpers/test_agent_card_display.py
@@ -0,0 +1,194 @@
+"""Tests for display_agent_card utility."""
+
+import pytest
+
+from a2a.helpers.agent_card import display_agent_card
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentProvider,
+    AgentSkill,
+)
+
+
+@pytest.fixture
+def full_agent_card() -> AgentCard:
+    return AgentCard(
+        name='Sample Agent',
+        description='A sample agent.',
+        version='1.0.0',
+        documentation_url='https://docs.example.com',
+        icon_url='https://example.com/icon.png',
+        provider=AgentProvider(
+            organization='Example Org', url='https://example.com'
+        ),
+        supported_interfaces=[
+            AgentInterface(
+                url='http://localhost:9999/a2a/jsonrpc',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            ),
+            AgentInterface(
+                url='http://localhost:9999/a2a/rest',
+                protocol_binding='HTTP+JSON',
+                protocol_version='1.0',
+                tenant='tenant-a',
+            ),
+        ],
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=False,
+            extended_agent_card=True,
+        ),
+        default_input_modes=['text'],
+        default_output_modes=['text', 'task-status'],
+        skills=[
+            AgentSkill(
+                id='skill-1',
+                name='My Skill',
+                description='Does something useful.',
+                tags=['foo', 'bar'],
+                examples=['Do the thing', 'Another example'],
+            ),
+            AgentSkill(
+                id='skill-2',
+                name='Other Skill',
+                description='Does something else.',
+                tags=['baz'],
+            ),
+        ],
+    )
+
+
+class TestDisplayAgentCard:
+    def test_full_card_output(
+        self, full_agent_card: AgentCard, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """Golden test: exact output for a fully-populated card."""
+        display_agent_card(full_agent_card)
+        assert capsys.readouterr().out == (
+            '====================================================\n'
+            '                     AgentCard                      \n'
+            '====================================================\n'
+            '--- General ---\n'
+            'Name        : Sample Agent\n'
+            'Description : A sample agent.\n'
+            'Version     : 1.0.0\n'
+            'Docs URL    : https://docs.example.com\n'
+            'Icon URL    : https://example.com/icon.png\n'
+            'Provider    : Example Org (https://example.com)\n'
+            '\n'
+            '--- Interfaces ---\n'
+            '  [0] http://localhost:9999/a2a/jsonrpc  (JSONRPC 1.0)\n'
+            '  [1] http://localhost:9999/a2a/rest  (HTTP+JSON 1.0, tenant=tenant-a)\n'
+            '\n'
+            '--- Capabilities ---\n'
+            'Streaming           : True\n'
+            'Push notifications  : False\n'
+            'Extended agent card : True\n'
+            '\n'
+            '--- I/O Modes ---\n'
+            'Input  : text\n'
+            'Output : text, task-status\n'
+            '\n'
+            '--- Skills ---\n'
+            '----------------------------------------------------\n'
+            '  ID          : skill-1\n'
+            '  Name        : My Skill\n'
+            '  Description : Does something useful.\n'
+            '  Tags        : foo, bar\n'
+            '  Example     : Do the thing\n'
+            '  Example     : Another example\n'
+            '----------------------------------------------------\n'
+            '  ID          : skill-2\n'
+            '  Name        : Other Skill\n'
+            '  Description : Does something else.\n'
+            '  Tags        : baz\n'
+            '====================================================\n'
+        )
+
+    def test_empty_card_output(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """Golden test: exact output for a card with only default/empty fields.
+
+        An empty supported_interfaces section signals a malformed card —
+        the bare header with no entries is intentional and visible to the user.
+        """
+        display_agent_card(AgentCard())
+        assert capsys.readouterr().out == (
+            '====================================================\n'
+            '                     AgentCard                      \n'
+            '====================================================\n'
+            '--- General ---\n'
+            'Name        : \n'
+            'Description : \n'
+            'Version     : \n'
+            '\n'
+            '--- Interfaces ---\n'
+            '\n'
+            '--- Capabilities ---\n'
+            'Streaming           : False\n'
+            'Push notifications  : False\n'
+            'Extended agent card : False\n'
+            '\n'
+            '--- I/O Modes ---\n'
+            'Input  : (none)\n'
+            'Output : (none)\n'
+            '\n'
+            '--- Skills ---\n'
+            '  (none)\n'
+            '====================================================\n'
+        )
+
+    def test_interface_without_protocol_version_has_no_trailing_space(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """No trailing space in the binding field when protocol_version is not set."""
+        card = AgentCard(
+            supported_interfaces=[
+                AgentInterface(
+                    url='127.0.0.1:50051',
+                    protocol_binding='GRPC',
+                )
+            ]
+        )
+        display_agent_card(card)
+        assert '  [0] 127.0.0.1:50051  (GRPC)' in capsys.readouterr().out
+
+    def test_interface_without_binding_or_version_has_no_parentheses(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """No parentheses when neither protocol_binding nor protocol_version are set."""
+        card = AgentCard(
+            supported_interfaces=[AgentInterface(url='127.0.0.1:50051')]
+        )
+        display_agent_card(card)
+        assert '  [0] 127.0.0.1:50051\n' in capsys.readouterr().out
+
+    def test_provider_with_url(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """Provider shows organization and URL in parentheses when both are set."""
+        card = AgentCard(
+            provider=AgentProvider(
+                organization='Example Org',
+                url='https://example.com',
+            ),
+        )
+        display_agent_card(card)
+        assert (
+            'Provider    : Example Org (https://example.com)'
+            in capsys.readouterr().out
+        )
+
+    def test_provider_without_url_has_no_empty_parentheses(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """No empty parentheses when provider URL is not set."""
+        card = AgentCard(provider=AgentProvider(organization='Example Org'))
+        display_agent_card(card)
+        out = capsys.readouterr().out
+        assert 'Provider    : Example Org' in out
+        assert '()' not in out
diff --git a/tests/helpers/test_proto_helpers.py b/tests/helpers/test_proto_helpers.py
new file mode 100644
index 000000000..a3080a7d7
--- /dev/null
+++ b/tests/helpers/test_proto_helpers.py
@@ -0,0 +1,624 @@
+"""Tests for proto helpers."""
+
+import pytest
+
+from a2a.helpers import (
+    get_artifact_text,
+    get_data_parts,
+    get_message_text,
+    get_raw_parts,
+    get_stream_response_text,
+    get_text_parts,
+    get_url_parts,
+    new_artifact,
+    new_data_artifact,
+    new_data_artifact_update_event,
+    new_data_message,
+    new_data_part,
+    new_message,
+    new_raw_artifact,
+    new_raw_artifact_update_event,
+    new_raw_message,
+    new_raw_part,
+    new_task,
+    new_task_from_user_message,
+    new_text_artifact,
+    new_text_artifact_update_event,
+    new_text_message,
+    new_text_part,
+    new_text_status_update_event,
+    new_url_artifact,
+    new_url_artifact_update_event,
+    new_url_message,
+    new_url_part,
+)
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    Message,
+    Part,
+    Role,
+    StreamResponse,
+    Task,
+    TaskState,
+)
+
+
+# --- Message Helpers Tests ---
+
+
+def test_new_message() -> None:
+    parts = [Part(text='hello')]
+    msg = new_message(
+        parts, context_id='ctx1', task_id='task1', role=Role.ROLE_USER
+    )
+    assert msg.role == Role.ROLE_USER
+    assert msg.parts == parts
+    assert msg.context_id == 'ctx1'
+    assert msg.task_id == 'task1'
+    assert msg.message_id != ''
+
+
+def test_new_text_message() -> None:
+    msg = new_text_message(
+        'hello',
+        media_type='text/plain',
+        context_id='ctx1',
+        task_id='task1',
+        role=Role.ROLE_USER,
+    )
+    assert msg.role == Role.ROLE_USER
+    assert len(msg.parts) == 1
+    assert msg.parts[0].text == 'hello'
+    assert msg.parts[0].media_type == 'text/plain'
+    assert msg.context_id == 'ctx1'
+    assert msg.task_id == 'task1'
+    assert msg.message_id != ''
+
+
+def test_new_data_message() -> None:
+    msg = new_data_message(
+        data={'key': 'value'},
+        media_type='application/json',
+        context_id='ctx1',
+        task_id='task1',
+        role=Role.ROLE_USER,
+    )
+    assert msg.role == Role.ROLE_USER
+    assert len(msg.parts) == 1
+    assert msg.parts[0].HasField('data')
+    assert msg.parts[0].data.struct_value.fields['key'].string_value == 'value'
+    assert msg.parts[0].media_type == 'application/json'
+    assert msg.context_id == 'ctx1'
+    assert msg.task_id == 'task1'
+    assert msg.message_id != ''
+
+
+def test_new_raw_message() -> None:
+    msg = new_raw_message(
+        b'\x89PNG',
+        media_type='image/png',
+        filename='img.png',
+        context_id='ctx1',
+        task_id='task1',
+        role=Role.ROLE_USER,
+    )
+    assert msg.role == Role.ROLE_USER
+    assert len(msg.parts) == 1
+    assert msg.parts[0].HasField('raw')
+    assert msg.parts[0].raw == b'\x89PNG'
+    assert msg.parts[0].media_type == 'image/png'
+    assert msg.parts[0].filename == 'img.png'
+    assert msg.context_id == 'ctx1'
+    assert msg.task_id == 'task1'
+    assert msg.message_id != ''
+
+
+def test_new_url_message() -> None:
+    msg = new_url_message(
+        'https://example.com/file.pdf',
+        media_type='application/pdf',
+        filename='file.pdf',
+        context_id='ctx1',
+        task_id='task1',
+        role=Role.ROLE_USER,
+    )
+    assert msg.role == Role.ROLE_USER
+    assert len(msg.parts) == 1
+    assert msg.parts[0].HasField('url')
+    assert msg.parts[0].url == 'https://example.com/file.pdf'
+    assert msg.parts[0].media_type == 'application/pdf'
+    assert msg.parts[0].filename == 'file.pdf'
+    assert msg.context_id == 'ctx1'
+    assert msg.task_id == 'task1'
+    assert msg.message_id != ''
+
+
+def test_get_message_text() -> None:
+    msg = Message(parts=[Part(text='hello'), Part(text='world')])
+    assert get_message_text(msg) == 'hello\nworld'
+    assert get_message_text(msg, delimiter=' ') == 'hello world'
+
+
+# --- Artifact Helpers Tests ---
+
+
+def test_new_artifact() -> None:
+    parts = [Part(text='content')]
+    art = new_artifact(parts=parts, name='test', description='desc')
+    assert art.name == 'test'
+    assert art.description == 'desc'
+    assert art.parts == parts
+    assert art.artifact_id != ''
+
+
+def test_new_text_artifact() -> None:
+    art = new_text_artifact(name='test', text='content', description='desc')
+    assert art.name == 'test'
+    assert art.description == 'desc'
+    assert len(art.parts) == 1
+    assert art.parts[0].text == 'content'
+    assert art.artifact_id != ''
+
+
+def test_new_text_artifact_with_id() -> None:
+    art = new_text_artifact(
+        name='test', text='content', description='desc', artifact_id='art1'
+    )
+    assert art.name == 'test'
+    assert art.description == 'desc'
+    assert len(art.parts) == 1
+    assert art.parts[0].text == 'content'
+    assert art.artifact_id == 'art1'
+
+
+def test_new_data_artifact() -> None:
+    art = new_data_artifact(
+        name='result', data={'score': 1.0}, description='desc'
+    )
+    assert art.name == 'result'
+    assert art.description == 'desc'
+    assert len(art.parts) == 1
+    assert art.parts[0].HasField('data')
+    assert art.parts[0].data.struct_value.fields['score'].number_value == 1.0
+    assert art.artifact_id != ''
+
+
+def test_new_data_artifact_with_id() -> None:
+    art = new_data_artifact(name='result', data={'x': 'y'}, artifact_id='art1')
+    assert art.artifact_id == 'art1'
+    assert art.parts[0].data.struct_value.fields['x'].string_value == 'y'
+
+
+def test_new_raw_artifact() -> None:
+    art = new_raw_artifact(
+        name='screenshot',
+        raw=b'\x89PNG',
+        media_type='image/png',
+        filename='screen.png',
+        description='desc',
+        artifact_id='art1',
+    )
+    assert art.name == 'screenshot'
+    assert art.description == 'desc'
+    assert art.artifact_id == 'art1'
+    assert len(art.parts) == 1
+    assert art.parts[0].HasField('raw')
+    assert art.parts[0].raw == b'\x89PNG'
+    assert art.parts[0].media_type == 'image/png'
+    assert art.parts[0].filename == 'screen.png'
+
+
+def test_new_raw_artifact_minimal() -> None:
+    art = new_raw_artifact(name='file', raw=b'data')
+    assert art.parts[0].raw == b'data'
+    assert art.artifact_id != ''
+
+
+def test_new_url_artifact() -> None:
+    art = new_url_artifact(
+        name='report',
+        url='https://example.com/report.pdf',
+        media_type='application/pdf',
+        filename='report.pdf',
+        description='desc',
+        artifact_id='art1',
+    )
+    assert art.name == 'report'
+    assert art.description == 'desc'
+    assert art.artifact_id == 'art1'
+    assert len(art.parts) == 1
+    assert art.parts[0].HasField('url')
+    assert art.parts[0].url == 'https://example.com/report.pdf'
+    assert art.parts[0].media_type == 'application/pdf'
+    assert art.parts[0].filename == 'report.pdf'
+
+
+def test_new_url_artifact_minimal() -> None:
+    art = new_url_artifact(name='img', url='https://example.com/img.png')
+    assert art.parts[0].url == 'https://example.com/img.png'
+    assert art.artifact_id != ''
+
+
+def test_get_artifact_text() -> None:
+    art = Artifact(parts=[Part(text='hello'), Part(text='world')])
+    assert get_artifact_text(art) == 'hello\nworld'
+    assert get_artifact_text(art, delimiter=' ') == 'hello world'
+
+
+# --- Task Helpers Tests ---
+
+
+def test_new_task_from_user_message() -> None:
+    msg = Message(
+        role=Role.ROLE_USER,
+        parts=[Part(text='hello')],
+        task_id='task1',
+        context_id='ctx1',
+    )
+    task = new_task_from_user_message(msg)
+    assert task.id == 'task1'
+    assert task.context_id == 'ctx1'
+    assert task.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert len(task.history) == 1
+    assert task.history[0] == msg
+
+
+def test_new_task_from_user_message_empty_parts() -> None:
+    msg = Message(role=Role.ROLE_USER, parts=[])
+    with pytest.raises(ValueError, match='Message parts cannot be empty'):
+        new_task_from_user_message(msg)
+
+
+def test_new_task_from_user_message_empty_text() -> None:
+    msg = Message(role=Role.ROLE_USER, parts=[Part(text='')])
+    with pytest.raises(ValueError, match='Message.text cannot be empty'):
+        new_task_from_user_message(msg)
+
+
+def test_new_task() -> None:
+    task = new_task(
+        task_id='task1', context_id='ctx1', state=TaskState.TASK_STATE_WORKING
+    )
+    assert task.id == 'task1'
+    assert task.context_id == 'ctx1'
+    assert task.status.state == TaskState.TASK_STATE_WORKING
+    assert len(task.history) == 0
+    assert len(task.artifacts) == 0
+
+
+# --- Part Helpers Tests ---
+
+
+def test_get_text_parts() -> None:
+    parts = [
+        Part(text='hello'),
+        Part(url='http://example.com'),
+        Part(text='world'),
+    ]
+    assert get_text_parts(parts) == ['hello', 'world']
+
+
+def test_new_text_part() -> None:
+    part = new_text_part('hello')
+    assert part.HasField('text')
+    assert part.text == 'hello'
+    assert part.media_type == ''
+
+
+def test_new_text_part_with_media_type() -> None:
+    part = new_text_part('# Hello', media_type='text/markdown')
+    assert part.HasField('text')
+    assert part.text == '# Hello'
+    assert part.media_type == 'text/markdown'
+
+
+def test_new_data_part_from_dict() -> None:
+    part = new_data_part({'key': 'value', 'count': 42})
+    assert part.HasField('data')
+    assert part.data.struct_value.fields['key'].string_value == 'value'
+    assert part.data.struct_value.fields['count'].number_value == 42
+    assert part.media_type == ''
+
+
+def test_new_data_part_with_media_type() -> None:
+    part = new_data_part({'key': 'value'}, media_type='application/json')
+    assert part.HasField('data')
+    assert part.media_type == 'application/json'
+
+
+def test_new_data_part_from_list() -> None:
+    part = new_data_part([1, 2, 3])
+    assert part.HasField('data')
+    assert part.data.list_value.values[0].number_value == 1
+    assert part.data.list_value.values[1].number_value == 2
+    assert part.data.list_value.values[2].number_value == 3
+
+
+def test_new_raw_part() -> None:
+    part = new_raw_part(b'\x89PNG', media_type='image/png', filename='img.png')
+    assert part.HasField('raw')
+    assert part.raw == b'\x89PNG'
+    assert part.media_type == 'image/png'
+    assert part.filename == 'img.png'
+
+
+def test_new_raw_part_minimal() -> None:
+    part = new_raw_part(b'data')
+    assert part.HasField('raw')
+    assert part.raw == b'data'
+    assert part.media_type == ''
+    assert part.filename == ''
+
+
+def test_new_url_part() -> None:
+    part = new_url_part(
+        'https://example.com/file.pdf',
+        media_type='application/pdf',
+        filename='file.pdf',
+    )
+    assert part.HasField('url')
+    assert part.url == 'https://example.com/file.pdf'
+    assert part.media_type == 'application/pdf'
+    assert part.filename == 'file.pdf'
+
+
+def test_new_url_part_minimal() -> None:
+    part = new_url_part('https://example.com/img.png')
+    assert part.HasField('url')
+    assert part.url == 'https://example.com/img.png'
+    assert part.media_type == ''
+    assert part.filename == ''
+
+
+# --- Event & Stream Helpers Tests ---
+
+
+def test_new_text_status_update_event() -> None:
+    event = new_text_status_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        state=TaskState.TASK_STATE_WORKING,
+        text='progress',
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.status.state == TaskState.TASK_STATE_WORKING
+    assert event.status.message.parts[0].text == 'progress'
+
+
+def test_new_text_artifact_update_event() -> None:
+    event = new_text_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='test',
+        text='content',
+        append=True,
+        last_chunk=True,
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.artifact.name == 'test'
+    assert event.artifact.parts[0].text == 'content'
+    assert event.append is True
+    assert event.last_chunk is True
+
+
+def test_new_text_artifact_update_event_with_id() -> None:
+    event = new_text_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='test',
+        text='content',
+        artifact_id='art1',
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.artifact.name == 'test'
+    assert event.artifact.parts[0].text == 'content'
+    assert event.artifact.artifact_id == 'art1'
+
+
+def test_get_stream_response_text_message() -> None:
+    resp = StreamResponse(message=Message(parts=[Part(text='hello')]))
+    assert get_stream_response_text(resp) == 'hello'
+
+
+def test_get_stream_response_text_task() -> None:
+    resp = StreamResponse(
+        task=Task(artifacts=[Artifact(parts=[Part(text='hello')])])
+    )
+    assert get_stream_response_text(resp) == 'hello'
+
+
+def test_get_stream_response_text_status_update() -> None:
+    resp = StreamResponse(
+        status_update=new_text_status_update_event(
+            't', 'c', TaskState.TASK_STATE_WORKING, 'hello'
+        )
+    )
+    assert get_stream_response_text(resp) == 'hello'
+
+
+def test_get_stream_response_text_artifact_update() -> None:
+    resp = StreamResponse(
+        artifact_update=new_text_artifact_update_event('t', 'c', 'n', 'hello')
+    )
+    assert get_stream_response_text(resp) == 'hello'
+
+
+def test_get_stream_response_text_empty() -> None:
+    resp = StreamResponse()
+    assert get_stream_response_text(resp) == ''
+
+
+# --- Part Extractor Tests ---
+
+
+def test_get_data_parts() -> None:
+    parts = [
+        new_data_part({'key': 'value'}),
+        Part(text='hello'),
+        new_data_part([1, 2]),
+    ]
+    result = get_data_parts(parts)
+    assert len(result) == 2
+    assert result[0] == {'key': 'value'}
+    assert result[1] == [1, 2]
+
+
+def test_get_data_parts_empty() -> None:
+    parts = [Part(text='hello'), Part(url='http://example.com')]
+    assert get_data_parts(parts) == []
+
+
+@pytest.mark.xfail(
+    reason='https://github.com/a2aproject/a2a-python/issues/1328',
+    strict=True,
+)
+def test_get_data_parts_keeps_whole_numbers_as_ints() -> None:
+    result = get_data_parts([new_data_part({'id': 4326, 'items': [240]})])
+    assert result == [{'id': 4326, 'items': [240]}]
+    assert isinstance(result[0]['id'], int)
+    assert isinstance(result[0]['items'][0], int)
+
+
+def test_get_raw_parts() -> None:
+    parts = [
+        Part(raw=b'\x89PNG'),
+        Part(text='hello'),
+        Part(raw=b'\xff\xd8'),
+    ]
+    result = get_raw_parts(parts)
+    assert result == [b'\x89PNG', b'\xff\xd8']
+
+
+def test_get_raw_parts_empty() -> None:
+    parts = [Part(text='hello')]
+    assert get_raw_parts(parts) == []
+
+
+def test_get_url_parts() -> None:
+    parts = [
+        Part(url='https://example.com/a.png'),
+        Part(text='hello'),
+        Part(url='https://example.com/b.pdf'),
+    ]
+    result = get_url_parts(parts)
+    assert result == [
+        'https://example.com/a.png',
+        'https://example.com/b.pdf',
+    ]
+
+
+def test_get_url_parts_empty() -> None:
+    parts = [Part(text='hello')]
+    assert get_url_parts(parts) == []
+
+
+# --- Non-text Artifact Update Event Tests ---
+
+
+def test_new_data_artifact_update_event() -> None:
+    event = new_data_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='result',
+        data={'score': 0.95},
+        media_type='application/json',
+        append=True,
+        last_chunk=True,
+        artifact_id='art1',
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.artifact.name == 'result'
+    assert event.artifact.artifact_id == 'art1'
+    assert event.artifact.parts[0].HasField('data')
+    assert (
+        event.artifact.parts[0].data.struct_value.fields['score'].number_value
+        == 0.95
+    )
+    assert event.artifact.parts[0].media_type == 'application/json'
+    assert event.append is True
+    assert event.last_chunk is True
+
+
+def test_new_data_artifact_update_event_minimal() -> None:
+    event = new_data_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='result',
+        data=[1, 2, 3],
+    )
+    assert event.artifact.parts[0].HasField('data')
+    assert event.append is False
+    assert event.last_chunk is False
+    assert event.artifact.artifact_id != ''
+
+
+def test_new_raw_artifact_update_event() -> None:
+    event = new_raw_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='screenshot',
+        raw=b'\x89PNG',
+        media_type='image/png',
+        filename='screen.png',
+        append=False,
+        last_chunk=True,
+        artifact_id='art1',
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.artifact.name == 'screenshot'
+    assert event.artifact.artifact_id == 'art1'
+    assert event.artifact.parts[0].HasField('raw')
+    assert event.artifact.parts[0].raw == b'\x89PNG'
+    assert event.artifact.parts[0].media_type == 'image/png'
+    assert event.artifact.parts[0].filename == 'screen.png'
+    assert event.last_chunk is True
+
+
+def test_new_raw_artifact_update_event_minimal() -> None:
+    event = new_raw_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='file',
+        raw=b'data',
+    )
+    assert event.artifact.parts[0].raw == b'data'
+    assert event.artifact.artifact_id != ''
+
+
+def test_new_url_artifact_update_event() -> None:
+    event = new_url_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='report',
+        url='https://example.com/report.pdf',
+        media_type='application/pdf',
+        filename='report.pdf',
+        append=True,
+        last_chunk=False,
+        artifact_id='art1',
+    )
+    assert event.task_id == 'task1'
+    assert event.context_id == 'ctx1'
+    assert event.artifact.name == 'report'
+    assert event.artifact.artifact_id == 'art1'
+    assert event.artifact.parts[0].HasField('url')
+    assert event.artifact.parts[0].url == 'https://example.com/report.pdf'
+    assert event.artifact.parts[0].media_type == 'application/pdf'
+    assert event.artifact.parts[0].filename == 'report.pdf'
+    assert event.append is True
+
+
+def test_new_url_artifact_update_event_minimal() -> None:
+    event = new_url_artifact_update_event(
+        task_id='task1',
+        context_id='ctx1',
+        name='img',
+        url='https://example.com/img.png',
+    )
+    assert event.artifact.parts[0].url == 'https://example.com/img.png'
+    assert event.artifact.artifact_id != ''
diff --git a/tests/install_smoke/README.md b/tests/install_smoke/README.md
new file mode 100644
index 000000000..6cc14a012
--- /dev/null
+++ b/tests/install_smoke/README.md
@@ -0,0 +1,39 @@
+# Install-smoke harness
+
+This package is **not** a pytest test suite. It is invoked as a
+standalone module from a freshly-installed, dev-deps-free venv:
+
+```bash
+python -m tests.install_smoke <profile>
+```
+
+The smoke venv is created by either
+[`scripts/test_install_smoke.sh`](../../scripts/test_install_smoke.sh)
+(local) or
+[`.github/workflows/install-smoke.yml`](../../.github/workflows/install-smoke.yml)
+(CI). The harness has no pytest dependency and uses only the Python
+standard library plus the freshly-installed `a2a-sdk` wheel for the
+profile under test.
+
+For a given install profile (`base`, `http-server`, `grpc`,
+`telemetry`, `sql`) it runs two phases:
+
+1. **Imports**: every module listed for the profile in `__main__.py`
+   must import cleanly. Catches missing deps and accidental top-level
+   imports of optional extras.
+2. **Runtime checks**: small public-API exercises that
+   actually call into the SDK. These catch regressions where imports
+   succeed but a real call fails.
+
+#### Adding a new runtime check
+
+1. Drop a module under `tests/install_smoke/runtime/` exposing two
+   names:
+   - `NAME: str` — short human-readable label.
+   - `check() -> None` — callable that raises on failure.
+2. Register it in `RUNTIME_CHECKS` in
+   [`__main__.py`](./__main__.py) under each profile whose extras it
+   needs.
+
+Use only the dependencies guaranteed by the target profile. Do not import 
+`pytest` or any dev-deps.
diff --git a/tests/install_smoke/__init__.py b/tests/install_smoke/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/install_smoke/__main__.py b/tests/install_smoke/__main__.py
new file mode 100644
index 000000000..87e216b72
--- /dev/null
+++ b/tests/install_smoke/__main__.py
@@ -0,0 +1,147 @@
+"""Entry point for the install-smoke harness. See README.md."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+
+
+# Modules under each list MUST be importable with only that profile's
+# extras installed -- no leakage from other extras (grpc, http-server,
+# sql, signing, telemetry, vertex, etc.). Modules that require
+# optional extras must use try/except ImportError guards internally.
+CORE_MODULES = [
+    'a2a',
+    'a2a.client',
+    'a2a.client.auth',
+    'a2a.client.base_client',
+    'a2a.client.card_resolver',
+    'a2a.client.client',
+    'a2a.client.client_factory',
+    'a2a.client.errors',
+    'a2a.client.interceptors',
+    'a2a.client.optionals',
+    'a2a.client.transports',
+    'a2a.server',
+    'a2a.server.agent_execution',
+    'a2a.server.context',
+    'a2a.server.events',
+    'a2a.server.request_handlers',
+    'a2a.server.tasks',
+    'a2a.types',
+    'a2a.utils',
+    'a2a.utils.constants',
+    'a2a.utils.error_handlers',
+    'a2a.utils.version_validator',
+    'a2a.utils.proto_utils',
+    'a2a.utils.task',
+    'a2a.helpers.agent_card',
+    'a2a.helpers.proto_helpers',
+]
+
+HTTP_SERVER_MODULES = [
+    'a2a.server.routes',
+    'a2a.server.routes.agent_card_routes',
+    'a2a.server.routes.common',
+    'a2a.server.routes.jsonrpc_dispatcher',
+    'a2a.server.routes.jsonrpc_routes',
+    'a2a.server.routes.rest_dispatcher',
+    'a2a.server.routes.rest_routes',
+]
+
+FASTAPI_MODULES = [
+    'a2a.server.routes.fastapi_routes',
+]
+
+GRPC_MODULES = [
+    'a2a.server.request_handlers.grpc_handler',
+    'a2a.client.transports.grpc',
+    'a2a.compat.v0_3.grpc_handler',
+    'a2a.compat.v0_3.grpc_transport',
+]
+
+TELEMETRY_MODULES = [
+    'a2a.utils.telemetry',
+]
+
+SQL_MODULES = [
+    'a2a.server.models',
+    'a2a.server.tasks.database_task_store',
+    'a2a.server.tasks.database_push_notification_config_store',
+]
+
+
+PROFILES: dict[str, list[str]] = {
+    'base': CORE_MODULES,
+    'http-server': CORE_MODULES + HTTP_SERVER_MODULES,
+    'fastapi': CORE_MODULES + HTTP_SERVER_MODULES + FASTAPI_MODULES,
+    'grpc': CORE_MODULES + GRPC_MODULES,
+    'telemetry': CORE_MODULES + TELEMETRY_MODULES,
+    'sql': CORE_MODULES + SQL_MODULES,
+}
+
+
+# Imported lazily in `main()` so a check that needs one profile's
+# extras can't break the harness when running a different profile.
+RUNTIME_CHECKS: dict[str, list[str]] = {
+    'base': ['tests.install_smoke.runtime.base_send_message'],
+}
+
+
+def main(argv: list[str]) -> int:
+    profile = argv[1] if len(argv) > 1 else 'base'
+    if profile not in PROFILES:
+        print(f'Unknown profile {profile!r}. Available: {sorted(PROFILES)}')
+        return 1
+
+    modules = PROFILES[profile]
+    import_failures: list[str] = []
+    for module_name in modules:
+        try:
+            importlib.import_module(module_name)
+        except Exception as e:  # noqa: BLE001, PERF203
+            import_failures.append(f'{module_name}: {e}')
+
+    print(f'Profile: {profile}')
+    print(f'Tested {len(modules)} modules')
+    print(f'  Passed: {len(modules) - len(import_failures)}')
+    print(f'  Failed: {len(import_failures)}')
+
+    if import_failures:
+        print('\nFAILED imports:')
+        for failure in import_failures:
+            print(f'  - {failure}')
+        return 1
+
+    print('\nAll modules imported successfully.')
+
+    runtime_checks = RUNTIME_CHECKS.get(profile, [])
+    if not runtime_checks:
+        return 0
+
+    print(f'\nRunning {len(runtime_checks)} runtime check(s):')
+    runtime_failures: list[str] = []
+    for module_path in runtime_checks:
+        label = module_path
+        try:
+            module = importlib.import_module(module_path)
+            label = module.NAME
+            module.check()
+        except Exception as e:  # noqa: BLE001, PERF203
+            runtime_failures.append(f'{label}: {type(e).__name__}: {e}')
+            print(f'  - FAIL: {label}')
+        else:
+            print(f'  - OK:   {label}')
+
+    if runtime_failures:
+        print('\nFAILED runtime checks:')
+        for failure in runtime_failures:
+            print(f'  - {failure}')
+        return 1
+
+    print('\nAll runtime checks passed.')
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))
diff --git a/tests/install_smoke/runtime/__init__.py b/tests/install_smoke/runtime/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/install_smoke/runtime/base_send_message.py b/tests/install_smoke/runtime/base_send_message.py
new file mode 100644
index 000000000..b9c38dde3
--- /dev/null
+++ b/tests/install_smoke/runtime/base_send_message.py
@@ -0,0 +1,97 @@
+"""Drive DefaultRequestHandler.on_message_send end-to-end with no transport.
+
+Exercises the request-validation path that regressed in
+https://github.com/a2aproject/a2a-python/pull/1019: a real proto
+instance flows through `validate_proto_required_fields`, which broke
+on protobuf 7. Pure imports cannot catch this class of regression.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    Task,
+    TaskState,
+)
+
+
+NAME = 'DefaultRequestHandler.on_message_send roundtrip'
+
+
+class _HelloAgentExecutor(AgentExecutor):
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        task = context.current_task
+        if not task:
+            assert context.message is not None
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.update_status(
+            TaskState.TASK_STATE_WORKING,
+            message=updater.new_agent_message([Part(text='I am working')]),
+        )
+        await updater.add_artifact(
+            [Part(text='Hello world!')], name='conversion_result'
+        )
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+async def _run() -> None:
+    handler = DefaultRequestHandler(
+        agent_executor=_HelloAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=AgentCard(
+            name='smoke',
+            version='1.0',
+            capabilities=AgentCapabilities(
+                streaming=True, push_notifications=False
+            ),
+        ),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='m1',
+            parts=[Part(text='hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+    result = await handler.on_message_send(params, ServerCallContext())
+    if not isinstance(result, Task):
+        raise AssertionError(  # noqa: TRY004
+            f'expected Task result, got {type(result).__name__}'
+        )
+    if result.status.state != TaskState.TASK_STATE_COMPLETED:
+        raise AssertionError(
+            f'expected TASK_STATE_COMPLETED, got '
+            f'{TaskState.Name(result.status.state)}'
+        )
+
+
+def check() -> None:
+    asyncio.run(_run())
diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/integration/cross_version/client_server/__init__.py b/tests/integration/cross_version/client_server/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/integration/cross_version/client_server/client_0_3.py b/tests/integration/cross_version/client_server/client_0_3.py
new file mode 100644
index 000000000..8a4f43d72
--- /dev/null
+++ b/tests/integration/cross_version/client_server/client_0_3.py
@@ -0,0 +1,303 @@
+import argparse
+import asyncio
+import sys
+import traceback
+
+from uuid import uuid4
+
+import grpc
+import httpx
+
+from a2a.client import ClientConfig, ClientFactory
+from a2a.types import (
+    DataPart,
+    FilePart,
+    FileWithBytes,
+    FileWithUri,
+    Message,
+    OAuth2SecurityScheme,
+    Part,
+    Role,
+    TaskIdParams,
+    TaskQueryParams,
+    TaskState,
+    TextPart,
+    TransportProtocol,
+)
+
+
+async def test_send_message_stream(client):
+    print('Testing send_message (streaming)...')
+
+    msg = Message(
+        role=Role.user,
+        message_id=f'stream-{uuid4()}',
+        parts=[
+            Part(root=TextPart(text='stream')),
+            Part(
+                root=FilePart(
+                    file=FileWithUri(
+                        uri='https://example.com/file.txt',
+                        mime_type='text/plain',
+                    )
+                )
+            ),
+            Part(
+                root=FilePart(
+                    file=FileWithBytes(
+                        bytes=b'aGVsbG8=', mime_type='application/octet-stream'
+                    )
+                )
+            ),
+            Part(root=DataPart(data={'key': 'value'})),
+        ],
+        metadata={'test_key': 'full_message'},
+    )
+    events = []
+
+    async for event in client.send_message(request=msg):
+        events.append(event)
+        break
+
+    assert len(events) > 0, 'Expected at least one event'
+    first_event = events[0]
+
+    event_obj = (
+        first_event[0] if isinstance(first_event, tuple) else first_event
+    )
+    task_id = getattr(event_obj, 'id', None) or getattr(
+        event_obj, 'task_id', 'unknown'
+    )
+
+    print(f'Success: send_message (streaming) passed. Task ID: {task_id}')
+    return task_id
+
+
+async def test_send_message_sync(url, protocol_enum):
+    print('Testing send_message (synchronous)...')
+    config = ClientConfig()
+    config.httpx_client = httpx.AsyncClient(timeout=30.0)
+    config.grpc_channel_factory = grpc.aio.insecure_channel
+    config.supported_transports = [protocol_enum]
+    config.streaming = False
+
+    client = await ClientFactory.connect(url, client_config=config)
+    msg = Message(
+        role=Role.user,
+        message_id=f'sync-{uuid4()}',
+        parts=[Part(root=TextPart(text='sync'))],
+        metadata={'test_key': 'simple_message'},
+    )
+
+    async for event in client.send_message(request=msg):
+        assert event is not None
+        event_obj = event[0] if isinstance(event, tuple) else event
+
+        status = getattr(event_obj, 'status', None)
+        if status and str(getattr(status, 'state', '')).endswith('completed'):
+            # In 0.3 SDK, the message on the status might be exposed as 'message' or 'update'
+            status_msg = getattr(
+                status, 'message', getattr(status, 'update', None)
+            )
+            assert status_msg is not None, (
+                'TaskStatus message/update is missing'
+            )
+
+            metadata = getattr(status_msg, 'metadata', {})
+            assert metadata.get('response_key') == 'response_value', (
+                f'Missing response metadata: {metadata}'
+            )
+
+            # Check Part translation (root text part in 0.3)
+            parts = getattr(
+                status_msg, 'parts', getattr(status_msg, 'content', [])
+            )
+            assert len(parts) > 0, 'No parts found in TaskStatus message'
+            first_part = parts[0]
+            text = getattr(first_part, 'text', '')
+            if (
+                not text
+                and hasattr(first_part, 'root')
+                and hasattr(first_part.root, 'text')
+            ):
+                text = first_part.root.text
+            assert text == 'done', f"Expected 'done' text in Part, got '{text}'"
+            break
+
+    print(f'Success: send_message (synchronous) passed.')
+
+
+async def test_get_task(client, task_id):
+    print(f'Testing get_task ({task_id})...')
+    task = await client.get_task(request=TaskQueryParams(id=task_id))
+    assert task.id == task_id
+
+    user_msgs = [
+        m for m in task.history if getattr(m, 'role', None) == Role.user
+    ]
+    assert user_msgs, 'Expected at least one ROLE_USER message in task history'
+
+    client_msg = user_msgs[0]
+
+    parts = client_msg.parts
+    assert len(parts) == 4, f'Expected 4 parts, got {len(parts)}'
+
+    # 1. text part
+    text = getattr(parts[0].root, 'text', '')
+    assert text == 'stream', f"Expected 'stream', got {text}"
+
+    # 2. uri part
+    file_uri = getattr(parts[1].root, 'file', None)
+    assert (
+        file_uri is not None
+        and getattr(file_uri, 'uri', None) == 'https://example.com/file.txt'
+    )
+
+    # 3. bytes part
+    file_bytes = getattr(parts[2].root, 'file', None)
+    actual_bytes = getattr(file_bytes, 'bytes', None)
+    assert actual_bytes == 'aGVsbG8=', (
+        f"Expected base64 'hello', got {actual_bytes}"
+    )
+
+    # 4. data part
+    data_val = getattr(parts[3].root, 'data', None)
+    assert data_val is not None
+    assert data_val == {'key': 'value'}
+
+    print('Success: get_task passed.')
+
+
+async def test_cancel_task(client, task_id):
+    print(f'Testing cancel_task ({task_id})...')
+    await client.cancel_task(request=TaskIdParams(id=task_id))
+    task = await client.get_task(request=TaskQueryParams(id=task_id))
+    assert task.status.state == TaskState.canceled, (
+        f'Expected a canceled state, got {task.status.state}'
+    )
+    print('Success: cancel_task passed.')
+
+
+async def test_subscribe(client, task_id):
+    print(f'Testing subscribe ({task_id})...')
+    has_artifact = False
+    async for event in client.resubscribe(request=TaskIdParams(id=task_id)):
+        # event is tuple (Task, UpdateEvent)
+        task, update = event
+        if update and hasattr(update, 'artifact'):
+            has_artifact = True
+            artifact = update.artifact
+            assert artifact.name == 'test-artifact'
+            assert artifact.metadata.get('artifact_key') == 'artifact_value'
+            # part check
+            assert len(artifact.parts) > 0
+            p = artifact.parts[0]
+            text = getattr(p.root, 'text', '')
+            assert text == 'artifact-chunk'
+            print('Success: received artifact update.')
+
+        if has_artifact:
+            break
+    print('Success: subscribe passed.')
+
+
+async def test_get_extended_agent_card(client):
+    print('Testing get_extended_agent_card...')
+    # In v0.3, extended card is fetched via get_card() on the client
+    card = await client.get_card()
+    assert card is not None
+    assert card.name in ('Server 0.3', 'Server 1.0')
+    assert card.version == '1.0.0'
+    assert 'Server running on a2a v' in card.description
+
+    assert card.capabilities is not None
+    assert card.capabilities.streaming is True
+    assert card.capabilities.push_notifications is True
+
+    if card.name == 'Server 0.3':
+        assert card.url is not None
+        assert card.preferred_transport == TransportProtocol.jsonrpc
+        assert len(card.additional_interfaces) == 2
+        assert card.supports_authenticated_extended_card is False
+    else:
+        assert card.url is not None
+        assert card.preferred_transport is not None
+        print(
+            f'card.supports_authenticated_extended_card is: {card.supports_authenticated_extended_card}'
+        )
+        assert card.supports_authenticated_extended_card is True
+
+        scheme = card.security_schemes['oauth'].root
+        assert isinstance(scheme, OAuth2SecurityScheme)
+        assert scheme.description == 'Device code'
+        # v0.3 has no device code flow, so the server sends no flows. The
+        # v0.3 gRPC client reads empty flows as a password flow with empty
+        # fields.
+        flows = scheme.flows
+        assert flows.authorization_code is None
+        assert flows.client_credentials is None
+        assert flows.implicit is None
+        assert flows.password is None or flows.password.token_url == ''
+
+    print(f'Success: get_extended_agent_card passed.')
+
+
+async def run_client(url: str, protocol: str):
+    protocol_enum_map = {
+        'jsonrpc': TransportProtocol.jsonrpc,
+        'rest': TransportProtocol.http_json,
+        'grpc': TransportProtocol.grpc,
+    }
+    protocol_enum = protocol_enum_map[protocol]
+
+    config = ClientConfig()
+    config.httpx_client = httpx.AsyncClient(timeout=30.0)
+    config.grpc_channel_factory = grpc.aio.insecure_channel
+    config.supported_transports = [protocol_enum]
+    config.streaming = True
+
+    client = await ClientFactory.connect(url, client_config=config)
+
+    # 1. Get Extended Agent Card
+    await test_get_extended_agent_card(client)
+
+    # 2. Send Streaming Message
+    task_id = await test_send_message_stream(client)
+
+    # 3. Get Task
+    await test_get_task(client, task_id)
+
+    # 4. Subscribe to Task
+    await test_subscribe(client, task_id)
+
+    # 5. Cancel Task
+    await test_cancel_task(client, task_id)
+
+    # 6. Send Sync Message
+    await test_send_message_sync(url, protocol_enum)
+
+
+def main():
+    print('Starting client_0_3...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--url', type=str, required=True)
+    parser.add_argument('--protocols', type=str, nargs='+', required=True)
+    args = parser.parse_args()
+
+    failed = False
+    for protocol in args.protocols:
+        print(f'\n=== Testing protocol: {protocol} ===')
+        try:
+            asyncio.run(run_client(args.url, protocol))
+        except Exception as e:
+            traceback.print_exc()
+            print(f'FAILED protocol {protocol}: {e}')
+            failed = True
+
+    if failed:
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/integration/cross_version/client_server/client_1_0.py b/tests/integration/cross_version/client_server/client_1_0.py
new file mode 100644
index 000000000..bdb868a00
--- /dev/null
+++ b/tests/integration/cross_version/client_server/client_1_0.py
@@ -0,0 +1,354 @@
+import argparse
+import asyncio
+import sys
+
+from uuid import uuid4
+
+import grpc
+import httpx
+
+from a2a.client import ClientConfig, create_client
+from a2a.client.errors import A2AClientError
+from a2a.types import (
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    TaskPushNotificationConfig,
+    TaskState,
+)
+from a2a.utils import TransportProtocol
+from google.protobuf.struct_pb2 import Struct, Value
+
+
+async def test_send_message_stream(client):
+    print('Testing send_message (streaming)...')
+
+    s = Struct()
+    s.update({'key': 'value'})
+
+    msg = Message(
+        role=Role.ROLE_USER,
+        message_id=f'stream-{uuid4()}',
+        parts=[
+            Part(text='stream'),
+            Part(url='https://example.com/file.txt', media_type='text/plain'),
+            Part(raw=b'hello', media_type='application/octet-stream'),
+            Part(data=Value(struct_value=s)),
+        ],
+        metadata={'test_key': 'full_message'},
+    )
+    events = []
+
+    async for event in client.send_message(
+        request=SendMessageRequest(message=msg)
+    ):
+        events.append(event)
+        break
+
+    assert len(events) > 0, 'Expected at least one event'
+    first_event = events[0]
+
+    # In v1.0 SDK, send_message returns StreamResponse
+    stream_response = first_event
+
+    # Try to find task_id in the oneof fields of StreamResponse
+    task_id = 'unknown'
+    if stream_response.HasField('task'):
+        task_id = stream_response.task.id
+    elif stream_response.HasField('message'):
+        task_id = stream_response.message.task_id
+    elif stream_response.HasField('status_update'):
+        task_id = stream_response.status_update.task_id
+    elif stream_response.HasField('artifact_update'):
+        task_id = stream_response.artifact_update.task_id
+
+    print(f'Success: send_message (streaming) passed. Task ID: {task_id}')
+    return task_id
+
+
+async def test_send_message_sync(url, protocol_enum):
+    print('Testing send_message (synchronous)...')
+    config = ClientConfig()
+    config.httpx_client = httpx.AsyncClient(timeout=30.0)
+    config.grpc_channel_factory = grpc.aio.insecure_channel
+    config.supported_protocol_bindings = [protocol_enum]
+    config.streaming = False
+
+    client = await create_client(url, client_config=config)
+    msg = Message(
+        role=Role.ROLE_USER,
+        message_id=f'sync-{uuid4()}',
+        parts=[Part(text='sync')],
+        metadata={'test_key': 'simple_message'},
+    )
+
+    async for event in client.send_message(
+        request=SendMessageRequest(message=msg)
+    ):
+        assert event is not None
+        stream_response = event
+
+        status = None
+        if stream_response.HasField('task'):
+            status = stream_response.task.status
+        elif stream_response.HasField('status_update'):
+            status = stream_response.status_update.status
+
+        if status and status.state == TaskState.TASK_STATE_COMPLETED:
+            metadata = dict(status.message.metadata)
+            assert metadata.get('response_key') == 'response_value', (
+                f'Missing response metadata: {metadata}'
+            )
+            assert status.message.parts[0].text == 'done'
+            break
+        else:
+            print(f'Ignore message: {stream_response}')
+
+    print(f'Success: send_message (synchronous) passed.')
+
+
+async def test_get_task(client, task_id):
+    print(f'Testing get_task ({task_id})...')
+    task = await client.get_task(request=GetTaskRequest(id=task_id))
+    assert task.id == task_id
+
+    user_msgs = [m for m in task.history if m.role == Role.ROLE_USER]
+    assert user_msgs, 'Expected at least one ROLE_USER message in task history'
+    client_msg = user_msgs[0]
+
+    assert len(client_msg.parts) == 4, (
+        f'Expected 4 parts, got {len(client_msg.parts)}'
+    )
+
+    # 1. text part
+    assert client_msg.parts[0].text == 'stream', (
+        f"Expected 'stream', got {client_msg.parts[0].text}"
+    )
+
+    # 2. uri part
+    assert client_msg.parts[1].url == 'https://example.com/file.txt'
+
+    # 3. bytes part
+    assert client_msg.parts[2].raw == b'hello'
+
+    # 4. data part
+    data_dict = dict(client_msg.parts[3].data.struct_value.fields)
+    assert data_dict['key'].string_value == 'value'
+
+    print('Success: get_task passed.')
+
+
+async def test_cancel_task(client, task_id):
+    print(f'Testing cancel_task ({task_id})...')
+    await client.cancel_task(request=CancelTaskRequest(id=task_id))
+    task = await client.get_task(request=GetTaskRequest(id=task_id))
+    assert task.status.state == TaskState.TASK_STATE_CANCELED, (
+        f'Expected {TaskState.TASK_STATE_CANCELED}, got {task.status.state}'
+    )
+    print('Success: cancel_task passed.')
+
+
+async def test_subscribe(client, task_id):
+    print(f'Testing subscribe ({task_id})...')
+    has_artifact = False
+    async for event in client.subscribe(
+        request=SubscribeToTaskRequest(id=task_id)
+    ):
+        assert event is not None
+        stream_response = event
+        if stream_response.HasField('artifact_update'):
+            has_artifact = True
+            artifact = stream_response.artifact_update.artifact
+            assert artifact.name == 'test-artifact'
+            val = artifact.metadata['artifact_key']
+            if hasattr(val, 'string_value'):
+                assert val.string_value == 'artifact_value'
+            else:
+                assert val == 'artifact_value'
+            assert artifact.parts[0].text == 'artifact-chunk'
+            print('Success: received artifact update.')
+
+        if has_artifact:
+            break
+    print('Success: subscribe passed.')
+
+
+async def test_list_tasks(client, server_name):
+    from a2a.types import ListTasksRequest
+
+    print('Testing list_tasks...')
+    try:
+        resp = await client.list_tasks(request=ListTasksRequest())
+        assert resp is not None
+        print(f'Success: list_tasks returned {len(resp.tasks)} tasks')
+    except NotImplementedError as e:
+        if server_name == 'Server 0.3':
+            print(f'Success: list_tasks gracefully failed on 0.3 Server: {e}')
+        else:
+            raise e
+
+
+async def test_get_extended_agent_card(client):
+    print('Testing get_extended_agent_card...')
+    card = await client.get_extended_agent_card(
+        request=GetExtendedAgentCardRequest()
+    )
+    assert card is not None
+    assert card.name in ('Server 0.3', 'Server 1.0')
+    assert card.version == '1.0.0'
+    assert 'Server running on a2a v' in card.description
+
+    assert card.capabilities is not None
+    assert card.capabilities.streaming is True
+    assert card.capabilities.push_notifications is True
+
+    if card.name == 'Server 1.0':
+        assert len(card.supported_interfaces) == 4
+        assert card.capabilities.extended_agent_card is True
+        flows = card.security_schemes['oauth'].oauth2_security_scheme.flows
+        assert flows.device_code.token_url == 'https://auth.example.com/token'
+    else:
+        assert len(card.supported_interfaces) > 0
+        assert card.capabilities.extended_agent_card in (False, None)
+
+    print(f'Success: get_extended_agent_card passed.')
+    return card.name
+
+
+async def test_push_notification_lifecycle(client, task_id, server_name):
+    print(f'Testing Push Notification lifecycle for task {task_id}...')
+    config_id = f'push-{uuid4()}'
+
+    # 1. Create
+    task_push_cfg = TaskPushNotificationConfig(
+        task_id=task_id, id=config_id, url='http://example.com/webhook'
+    )
+
+    created = await client.create_task_push_notification_config(
+        request=task_push_cfg
+    )
+    assert created.id == config_id
+    print('Success: create_task_push_notification_config passed.')
+
+    # 2. Get
+    get_req = GetTaskPushNotificationConfigRequest(
+        task_id=task_id, id=config_id
+    )
+    fetched = await client.get_task_push_notification_config(request=get_req)
+    assert fetched.id == config_id
+    print('Success: get_task_push_notification_config passed.')
+
+    # 3. List
+    try:
+        list_req = ListTaskPushNotificationConfigsRequest(task_id=task_id)
+        listed = await client.list_task_push_notification_configs(
+            request=list_req
+        )
+        assert any(c.id == config_id for c in listed.configs)
+    except (NotImplementedError, A2AClientError) as e:
+        if server_name == 'Server 0.3':
+            print(
+                'EXPECTED: list_task_push_notification_configs not implemented'
+            )
+        else:
+            raise e
+    print('Success: list_task_push_notification_configs passed.')
+
+    try:
+        # 4. Delete
+        del_req = DeleteTaskPushNotificationConfigRequest(
+            task_id=task_id, id=config_id
+        )
+        await client.delete_task_push_notification_config(request=del_req)
+        print('Success: delete_task_push_notification_config passed.')
+
+        # Verify deletion
+        listed_after = await client.list_task_push_notification_configs(
+            request=list_req
+        )
+        assert not any(c.id == config_id for c in listed_after.configs)
+        print('Success: verified deletion.')
+    except (NotImplementedError, A2AClientError) as e:
+        if server_name == 'Server 0.3':
+            print(
+                'EXPECTED: delete_task_push_notification_config not implemented'
+            )
+        else:
+            raise e
+
+
+async def run_client(url: str, protocol: str):
+    protocol_enum_map = {
+        'jsonrpc': TransportProtocol.JSONRPC,
+        'rest': TransportProtocol.HTTP_JSON,
+        'grpc': TransportProtocol.GRPC,
+    }
+    protocol_enum = protocol_enum_map[protocol]
+
+    config = ClientConfig()
+    config.httpx_client = httpx.AsyncClient(timeout=30.0)
+    config.grpc_channel_factory = grpc.aio.insecure_channel
+    config.supported_protocol_bindings = [protocol_enum]
+    config.streaming = True
+
+    client = await create_client(url, client_config=config)
+
+    # 1. Get Extended Agent Card
+    server_name = await test_get_extended_agent_card(client)
+
+    # 1.5. List Tasks
+    await test_list_tasks(client, server_name)
+
+    # 2. Send Streaming Message
+    task_id = await test_send_message_stream(client)
+
+    # 3. Get Task
+    await test_get_task(client, task_id)
+
+    # 3.5 Push Notification Lifecycle
+    await test_push_notification_lifecycle(client, task_id, server_name)
+
+    # 4. Subscribe to Task
+    await test_subscribe(client, task_id)
+
+    # 5. Cancel Task
+    await test_cancel_task(client, task_id)
+
+    # 6. Send Sync Message
+    await test_send_message_sync(url, protocol_enum)
+
+
+def main():
+    print('Starting client_1_0...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--url', type=str, required=True)
+    parser.add_argument('--protocols', type=str, nargs='+', required=True)
+    args = parser.parse_args()
+
+    failed = False
+    for protocol in args.protocols:
+        print(f'\n=== Testing protocol: {protocol} ===')
+        try:
+            asyncio.run(run_client(args.url, protocol))
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            print(f'FAILED protocol {protocol}: {e}')
+            failed = True
+
+    if failed:
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/integration/cross_version/client_server/server_0_3.py b/tests/integration/cross_version/client_server/server_0_3.py
new file mode 100644
index 000000000..75eef3858
--- /dev/null
+++ b/tests/integration/cross_version/client_server/server_0_3.py
@@ -0,0 +1,234 @@
+import argparse
+import asyncio
+
+import grpc
+import uvicorn
+
+from a2a.grpc import a2a_pb2_grpc
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.apps.jsonrpc.fastapi_app import A2AFastAPIApplication
+from a2a.server.apps.rest.fastapi_app import A2ARESTFastAPIApplication
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers.default_request_handler import (
+    DefaultRequestHandler,
+)
+from a2a.server.request_handlers.grpc_handler import GrpcHandler
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    DataPart,
+    FilePart,
+    FileWithBytes,
+    FileWithUri,
+    Part,
+    TaskState,
+    TextPart,
+    TransportProtocol,
+)
+from a2a.utils.task import new_task
+from fastapi import FastAPI
+from server_common import CustomLoggingMiddleware
+
+
+class MockAgentExecutor(AgentExecutor):
+    def __init__(self):
+        self.events = {}
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        print(f'SERVER: execute called for task {context.task_id}')
+
+        task = new_task(context.message)
+        task.id = context.task_id
+        task.context_id = context.context_id
+        task.status.state = TaskState.working
+        await event_queue.enqueue_event(task)
+
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+        await task_updater.update_status(TaskState.working)
+
+        text = ''
+        if context.message and context.message.parts:
+            part = context.message.parts[0]
+            if hasattr(part, 'root') and hasattr(part.root, 'text'):
+                text = part.root.text
+            elif hasattr(part, 'text'):
+                text = part.text
+
+        metadata = (
+            dict(context.message.metadata)
+            if context.message and context.message.metadata
+            else {}
+        )
+        if metadata.get('test_key') not in ('full_message', 'simple_message'):
+            print(f'SERVER: WARNING: Missing or incorrect metadata: {metadata}')
+            raise ValueError(
+                f'Missing expected metadata from client. Got: {metadata}'
+            )
+
+        if metadata.get('test_key') == 'full_message':
+            expected_parts = [
+                Part(root=TextPart(text='stream')),
+                Part(
+                    root=FilePart(
+                        file=FileWithUri(
+                            uri='https://example.com/file.txt',
+                            mime_type='text/plain',
+                        )
+                    )
+                ),
+                Part(
+                    root=FilePart(
+                        file=FileWithBytes(
+                            bytes=b'aGVsbG8=',
+                            mime_type='application/octet-stream',
+                        )
+                    )
+                ),
+                Part(root=DataPart(data={'key': 'value'})),
+            ]
+            assert context.message.parts == expected_parts
+
+        print(f"SERVER: request message text='{text}'")
+
+        if 'stream' in text:
+            print(f'SERVER: waiting on stream event for task {context.task_id}')
+            event = asyncio.Event()
+            self.events[context.task_id] = event
+
+            async def emit_periodic():
+                try:
+                    while not event.is_set():
+                        await task_updater.update_status(
+                            TaskState.working,
+                            message=task_updater.new_agent_message(
+                                [Part(root=TextPart(text='ping'))]
+                            ),
+                        )
+                        await task_updater.add_artifact(
+                            [Part(root=TextPart(text='artifact-chunk'))],
+                            name='test-artifact',
+                            metadata={'artifact_key': 'artifact_value'},
+                        )
+                        await asyncio.sleep(0.1)
+                except asyncio.CancelledError:
+                    pass
+
+            bg_task = asyncio.create_task(emit_periodic())
+
+            await event.wait()
+            bg_task.cancel()
+
+            print(f'SERVER: stream event triggered for task {context.task_id}')
+
+        await task_updater.update_status(
+            TaskState.completed,
+            message=task_updater.new_agent_message(
+                [Part(root=TextPart(text='done'))],
+                metadata={'response_key': 'response_value'},
+            ),
+        )
+        print(f'SERVER: execute finished for task {context.task_id}')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        print(f'SERVER: cancel called for task {context.task_id}')
+        assert context.task_id in self.events
+        self.events[context.task_id].set()
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+        await task_updater.update_status(TaskState.canceled)
+
+
+async def main_async(http_port: int, grpc_port: int):
+    print(
+        f'SERVER: Starting server on http_port={http_port}, grpc_port={grpc_port}'
+    )
+
+    agent_card = AgentCard(
+        name='Server 0.3',
+        description='Server running on a2a v0.3.0',
+        version='1.0.0',
+        url=f'http://127.0.0.1:{http_port}/jsonrpc/',
+        preferred_transport=TransportProtocol.jsonrpc,
+        skills=[],
+        capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        additional_interfaces=[
+            AgentInterface(
+                transport=TransportProtocol.http_json,
+                url=f'http://127.0.0.1:{http_port}/rest/',
+            ),
+            AgentInterface(
+                transport=TransportProtocol.grpc,
+                url=f'127.0.0.1:{grpc_port}',
+            ),
+        ],
+        supports_authenticated_extended_card=False,
+    )
+
+    task_store = InMemoryTaskStore()
+    handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        queue_manager=InMemoryQueueManager(),
+        push_config_store=InMemoryPushNotificationConfigStore(),
+    )
+
+    app = FastAPI()
+    app.mount(
+        '/jsonrpc',
+        A2AFastAPIApplication(
+            http_handler=handler, agent_card=agent_card
+        ).build(),
+    )
+    app.mount(
+        '/rest',
+        A2ARESTFastAPIApplication(
+            http_handler=handler, agent_card=agent_card
+        ).build(),
+    )
+    # Start gRPC Server
+    server = grpc.aio.server()
+    servicer = GrpcHandler(agent_card, handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+    server.add_insecure_port(f'127.0.0.1:{grpc_port}')
+    await server.start()
+
+    app.add_middleware(CustomLoggingMiddleware)
+
+    # Start Uvicorn
+    config = uvicorn.Config(
+        app, host='127.0.0.1', port=http_port, log_level='info', access_log=True
+    )
+    uvicorn_server = uvicorn.Server(config)
+    await uvicorn_server.serve()
+
+
+def main():
+    print('Starting server_0_3...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--http-port', type=int, required=True)
+    parser.add_argument('--grpc-port', type=int, required=True)
+    args = parser.parse_args()
+
+    asyncio.run(main_async(args.http_port, args.grpc_port))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/integration/cross_version/client_server/server_1_0.py b/tests/integration/cross_version/client_server/server_1_0.py
new file mode 100644
index 000000000..152d1eb52
--- /dev/null
+++ b/tests/integration/cross_version/client_server/server_1_0.py
@@ -0,0 +1,256 @@
+import argparse
+import asyncio
+
+import grpc
+import uvicorn
+
+from a2a.compat.v0_3 import a2a_v0_3_pb2_grpc
+from a2a.compat.v0_3.grpc_handler import CompatGrpcHandler
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler, GrpcHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks import TaskUpdater
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    DeviceCodeOAuthFlow,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    Part,
+    SecurityScheme,
+    TaskState,
+)
+from a2a.utils import TransportProtocol
+from fastapi import FastAPI
+from google.protobuf.struct_pb2 import Struct, Value
+from server_common import CustomLoggingMiddleware
+
+
+class MockAgentExecutor(AgentExecutor):
+    def __init__(self):
+        self.events = {}
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        print(f'SERVER: execute called for task {context.task_id}')
+        task = new_task_from_user_message(context.message)
+        task.id = context.task_id
+        task.context_id = context.context_id
+        task.status.state = TaskState.TASK_STATE_WORKING
+        await event_queue.enqueue_event(task)
+
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+        await task_updater.update_status(TaskState.TASK_STATE_WORKING)
+
+        text = ''
+        if context.message and context.message.parts:
+            text = context.message.parts[0].text
+
+        metadata = (
+            dict(context.message.metadata)
+            if context.message and context.message.metadata
+            else {}
+        )
+        if metadata.get('test_key') not in ('full_message', 'simple_message'):
+            print(f'SERVER: WARNING: Missing or incorrect metadata: {metadata}')
+            raise ValueError(
+                f'Missing expected metadata from client. Got: {metadata}'
+            )
+
+        for part in context.message.parts:
+            if part.HasField('raw'):
+                assert part.raw == b'hello'
+
+        if metadata.get('test_key') == 'full_message':
+            s = Struct()
+            s.update({'key': 'value'})
+
+            expected_parts = [
+                Part(text='stream'),
+                Part(
+                    url='https://example.com/file.txt', media_type='text/plain'
+                ),
+                Part(raw=b'hello', media_type='application/octet-stream'),
+                Part(data=Value(struct_value=s)),
+            ]
+            assert context.message.parts == expected_parts
+
+        if 'stream' in text:
+            print(f'SERVER: waiting on stream event for task {context.task_id}')
+            event = asyncio.Event()
+            self.events[context.task_id] = event
+
+            async def emit_periodic():
+                try:
+                    while not event.is_set():
+                        await task_updater.update_status(
+                            TaskState.TASK_STATE_WORKING,
+                            message=task_updater.new_agent_message(
+                                [Part(text='ping')]
+                            ),
+                        )
+                        await task_updater.add_artifact(
+                            [Part(text='artifact-chunk')],
+                            name='test-artifact',
+                            metadata={'artifact_key': 'artifact_value'},
+                        )
+                        await asyncio.sleep(0.1)
+                except asyncio.CancelledError:
+                    pass
+
+            bg_task = asyncio.create_task(emit_periodic())
+            await event.wait()
+            bg_task.cancel()
+            print(f'SERVER: stream event triggered for task {context.task_id}')
+
+        await task_updater.update_status(
+            TaskState.TASK_STATE_COMPLETED,
+            message=task_updater.new_agent_message(
+                [Part(text='done')], metadata={'response_key': 'response_value'}
+            ),
+        )
+        print(f'SERVER: execute finished for task {context.task_id}')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        print(f'SERVER: cancel called for task {context.task_id}')
+        assert context.task_id in self.events
+        self.events[context.task_id].set()
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+        await task_updater.update_status(TaskState.TASK_STATE_CANCELED)
+
+
+async def main_async(http_port: int, grpc_port: int):
+    agent_card = AgentCard(
+        name='Server 1.0',
+        description='Server running on a2a v1.0',
+        version='1.0.0',
+        skills=[],
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            # Makes v0.3 clients fetch the extended card from the server.
+            extended_agent_card=True,
+        ),
+        # v0.3 has no device code flow, so v0.3 clients get no flows.
+        security_schemes={
+            'oauth': SecurityScheme(
+                oauth2_security_scheme=OAuth2SecurityScheme(
+                    description='Device code',
+                    flows=OAuthFlows(
+                        device_code=DeviceCodeOAuthFlow(
+                            device_authorization_url='https://auth.example.com/device',
+                            token_url='https://auth.example.com/token',
+                            scopes={'read': 'Read access'},
+                        )
+                    ),
+                )
+            )
+        },
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url=f'http://127.0.0.1:{http_port}/jsonrpc/',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url=f'http://127.0.0.1:{http_port}/rest/',
+                protocol_version='1.0',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url=f'http://127.0.0.1:{http_port}/rest/',
+                protocol_version='0.3',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url=f'127.0.0.1:{grpc_port}',
+            ),
+        ],
+    )
+
+    task_store = InMemoryTaskStore()
+    handler = DefaultRequestHandler(
+        MockAgentExecutor(),
+        task_store,
+        agent_card,
+        queue_manager=InMemoryQueueManager(),
+        push_config_store=InMemoryPushNotificationConfigStore(),
+        extended_agent_card=agent_card,
+    )
+
+    app = FastAPI()
+    app.add_middleware(CustomLoggingMiddleware)
+
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/.well-known/agent-card.json'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler,
+        rpc_url='/',
+        enable_v0_3_compat=True,
+    )
+    app.mount(
+        '/jsonrpc',
+        FastAPI(routes=jsonrpc_routes + agent_card_routes),
+    )
+
+    rest_routes = create_rest_routes(
+        request_handler=handler,
+        enable_v0_3_compat=True,
+    )
+    app.mount(
+        '/rest',
+        FastAPI(routes=rest_routes + agent_card_routes),
+    )
+
+    # Start gRPC Server
+    server = grpc.aio.server()
+    servicer = GrpcHandler(handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+
+    compat_servicer = CompatGrpcHandler(handler)
+    a2a_v0_3_pb2_grpc.add_A2AServiceServicer_to_server(compat_servicer, server)
+
+    server.add_insecure_port(f'127.0.0.1:{grpc_port}')
+    await server.start()
+
+    # Start Uvicorn
+    config = uvicorn.Config(
+        app, host='127.0.0.1', port=http_port, log_level='info', access_log=True
+    )
+    uvicorn_server = uvicorn.Server(config)
+    await uvicorn_server.serve()
+
+
+def main():
+    print('Starting server_1_0...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--http-port', type=int, required=True)
+    parser.add_argument('--grpc-port', type=int, required=True)
+    args = parser.parse_args()
+
+    asyncio.run(main_async(args.http_port, args.grpc_port))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/integration/cross_version/client_server/server_common.py b/tests/integration/cross_version/client_server/server_common.py
new file mode 100644
index 000000000..2694ebc75
--- /dev/null
+++ b/tests/integration/cross_version/client_server/server_common.py
@@ -0,0 +1,49 @@
+import collections.abc
+
+from typing import AsyncGenerator
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+
+class PrintingAsyncGenerator(collections.abc.AsyncGenerator):
+    """
+    Wraps an async generator to print items as they are yielded,
+    fully supporting bi-directional flow (asend, athrow, aclose).
+    """
+
+    def __init__(self, url: str, ag: AsyncGenerator):
+        self.url = url
+        self._ag = ag
+
+    async def asend(self, value):
+        # Forward the sent value to the underlying async generator
+        result = await self._ag.asend(value)
+        print(f'PrintingAsyncGenerator::Generated: {self.url} {result}')
+        return result
+
+    async def athrow(self, typ, val=None, tb=None):
+        # Forward exceptions to the underlying async generator
+        result = await self._ag.athrow(typ, val, tb)
+        print(
+            f'PrintingAsyncGenerator::Generated (via athrow): {self.url} {result}'
+        )
+        return result
+
+    async def aclose(self):
+        # Gracefully shut down the underlying generator
+        await self._ag.aclose()
+
+
+class CustomLoggingMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        print('-' * 80)
+        print(f'REQUEST: {request.method} {request.url}')
+        print(f'REQUEST BODY: {await request.body()}')
+
+        response = await call_next(request)
+        # Disabled by default. Can hang the test if enabled.
+        # response.body_iterator = PrintingAsyncGenerator(request.url, response.body_iterator)
+
+        print('-' * 80)
+        return response
diff --git a/tests/integration/cross_version/client_server/test_client_server.py b/tests/integration/cross_version/client_server/test_client_server.py
new file mode 100644
index 000000000..d46582ea9
--- /dev/null
+++ b/tests/integration/cross_version/client_server/test_client_server.py
@@ -0,0 +1,254 @@
+import os
+import shutil
+import signal
+import socket
+import subprocess
+import time
+
+import pytest
+
+
+# Use --isolated to not to pull project .venv.
+LEGACY_ENV_FLAGS = ['--no-project', '--isolated']
+CLIENT_03_DEPS = ['--with', 'a2a-sdk[grpc]==0.3.24', *LEGACY_ENV_FLAGS]
+
+
+def get_free_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def wait_for_port(proc: subprocess.Popen, proc_name: str, port, timeout=5.0):
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        print(
+            f'Waiting for port {port} to be available for {timeout - (time.time() - start_time)} seconds...'
+        )
+        try:
+            if proc.poll() is not None:
+                print(
+                    f'Process {proc_name} died before port {port} was available'
+                )
+                return False
+            with socket.create_connection(('127.0.0.1', port), timeout=0.1):
+                return True
+        except OSError:
+            time.sleep(0.1)
+    return False
+
+
+def get_env(script: str) -> dict[str, str]:
+    new_env = os.environ.copy()
+    new_env['PYTHONUNBUFFERED'] = '1'
+    if '_1_0.py' in script:
+        new_env['PYTHONPATH'] = (
+            os.path.abspath('src') + ':' + new_env.get('PYTHONPATH', '')
+        )
+    return new_env
+
+
+def finalize_process(
+    proc: subprocess.Popen,
+    name: str,
+    expected_return_code=None,
+    timeout: float = 5.0,
+):
+    failure = False
+    if expected_return_code is not None:
+        try:
+            print(f'Waiting for process {name} to finish...')
+            if proc.wait(timeout=timeout) != expected_return_code:
+                print(
+                    f'Process {name} returned code {proc.returncode}, expected {expected_return_code}'
+                )
+                failure = True
+        except subprocess.TimeoutExpired:
+            print(f'Process {name} timed out after {timeout} seconds')
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+            failure = True
+    else:
+        if proc.poll() is None:
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        else:
+            print(f'Process {name} already terminated!')
+            failure = True
+
+    try:
+        proc.wait(timeout=2)
+    except subprocess.TimeoutExpired:
+        os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+
+    print(f'Process {name} finished with code {proc.wait()}')
+
+    stdout_text, stderr_text = proc.communicate(timeout=3.0)
+
+    print('-' * 80)
+    print(f'Process {name} STDOUT:\n{stdout_text}')
+    print('-' * 80)
+    print(f'Process {name} STDERR:\n{stderr_text}')
+    print('-' * 80)
+    if failure:
+        pytest.fail(f'Process {name} failed.')
+
+
+@pytest.fixture(scope='session')
+def running_servers():
+    uv_path = shutil.which('uv')
+    if not os.path.exists(uv_path):
+        pytest.fail(f"Could not find 'uv' executable at {uv_path}")
+
+    # Server 1.0 setup
+    s10_http_port = get_free_port()
+    s10_grpc_port = get_free_port()
+    s10_deps = ['--with', 'uvicorn', '--with', 'fastapi', '--with', 'grpcio']
+    s10_cmd = (
+        [uv_path, 'run']
+        + s10_deps
+        + [
+            'python',
+            'tests/integration/cross_version/client_server/server_1_0.py',
+            '--http-port',
+            str(s10_http_port),
+            '--grpc-port',
+            str(s10_grpc_port),
+        ]
+    )
+    s10_proc = subprocess.Popen(
+        s10_cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=get_env('server_1_0.py'),
+        text=True,
+        start_new_session=True,
+    )
+
+    # Server 0.3 setup
+    s03_http_port = get_free_port()
+    s03_grpc_port = get_free_port()
+    s03_deps = [
+        '--with',
+        'a2a-sdk[grpc,http-server]==0.3.24',
+        '--with',
+        'uvicorn',
+        '--with',
+        'fastapi',
+        *LEGACY_ENV_FLAGS,
+    ]
+    s03_cmd = (
+        [uv_path, 'run']
+        + s03_deps
+        + [
+            'python',
+            'tests/integration/cross_version/client_server/server_0_3.py',
+            '--http-port',
+            str(s03_http_port),
+            '--grpc-port',
+            str(s03_grpc_port),
+        ]
+    )
+    s03_proc = subprocess.Popen(
+        s03_cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=get_env('server_0_3.py'),
+        text=True,
+        start_new_session=True,
+    )
+
+    try:
+        # Wait for ports
+        assert wait_for_port(
+            s10_proc, 'server_1_0.py', s10_http_port, timeout=3.0
+        ), 'Server 1.0 HTTP failed to start'
+        assert wait_for_port(
+            s10_proc, 'server_1_0.py', s10_grpc_port, timeout=3.0
+        ), 'Server 1.0 GRPC failed to start'
+        assert wait_for_port(
+            s03_proc, 'server_0_3.py', s03_http_port, timeout=3.0
+        ), 'Server 0.3 HTTP failed to start'
+        assert wait_for_port(
+            s03_proc, 'server_0_3.py', s03_grpc_port, timeout=3.0
+        ), 'Server 0.3 GRPC failed to start'
+
+        print('SERVER READY')
+
+        yield {
+            'server_1_0.py': s10_http_port,
+            'server_0_3.py': s03_http_port,
+            'uv_path': uv_path,
+            'procs': {'server_1_0.py': s10_proc, 'server_0_3.py': s03_proc},
+        }
+
+    finally:
+        print('SERVER CLEANUP')
+        for proc, name in [
+            (s03_proc, 'server_0_3.py'),
+            (s10_proc, 'server_1_0.py'),
+        ]:
+            finalize_process(proc, name)
+
+
+@pytest.mark.timeout(15)
+@pytest.mark.parametrize(
+    'server_script, client_script, client_deps, protocols',
+    [
+        # Run 0.3 Server <-> 0.3 Client
+        (
+            'server_0_3.py',
+            'client_0_3.py',
+            CLIENT_03_DEPS,
+            ['grpc', 'jsonrpc', 'rest'],
+        ),
+        # Run 1.0 Server <-> 0.3 Client
+        (
+            'server_1_0.py',
+            'client_0_3.py',
+            CLIENT_03_DEPS,
+            ['grpc', 'jsonrpc', 'rest'],
+        ),
+        # Run 1.0 Server <-> 1.0 Client
+        (
+            'server_1_0.py',
+            'client_1_0.py',
+            [],
+            ['grpc', 'jsonrpc', 'rest'],
+        ),
+        # Run 0.3 Server <-> 1.0 Client
+        (
+            'server_0_3.py',
+            'client_1_0.py',
+            [],
+            ['grpc', 'jsonrpc', 'rest'],
+        ),
+    ],
+)
+def test_cross_version(
+    running_servers, server_script, client_script, client_deps, protocols
+):
+    http_port = running_servers[server_script]
+    uv_path = running_servers['uv_path']
+
+    card_url = f'http://127.0.0.1:{http_port}/jsonrpc/'
+    client_cmd = (
+        [uv_path, 'run']
+        + client_deps
+        + [
+            'python',
+            f'tests/integration/cross_version/client_server/{client_script}',
+            '--url',
+            card_url,
+            '--protocols',
+        ]
+        + protocols
+    )
+
+    client_result = subprocess.Popen(
+        client_cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=get_env(client_script),
+        text=True,
+        start_new_session=True,
+    )
+    finalize_process(client_result, client_script, 0)
diff --git a/tests/integration/cross_version/test_cross_version_card_validation.py b/tests/integration/cross_version/test_cross_version_card_validation.py
new file mode 100644
index 000000000..a72707603
--- /dev/null
+++ b/tests/integration/cross_version/test_cross_version_card_validation.py
@@ -0,0 +1,200 @@
+import json
+import subprocess
+
+from a2a.client.card_resolver import parse_agent_card
+from a2a.server.request_handlers.response_helpers import agent_card_to_dict
+from a2a.types.a2a_pb2 import (
+    APIKeySecurityScheme,
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    AuthorizationCodeOAuthFlow,
+    HTTPAuthSecurityScheme,
+    MutualTlsSecurityScheme,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    OpenIdConnectSecurityScheme,
+    SecurityRequirement,
+    SecurityScheme,
+    StringList,
+)
+from google.protobuf.json_format import MessageToDict, ParseDict
+
+
+def test_cross_version_agent_card_deserialization() -> None:
+    # 1. Complex card
+    complex_card = AgentCard(
+        name='Complex Agent 0.3',
+        description='A very complex agent from 0.3.0',
+        version='1.5.2',
+        capabilities=AgentCapabilities(
+            extended_agent_card=True, streaming=True, push_notifications=True
+        ),
+        default_input_modes=['text/plain', 'application/json'],
+        default_output_modes=['application/json', 'image/png'],
+        supported_interfaces=[
+            AgentInterface(
+                url='http://complex.agent.example.com/api',
+                protocol_binding='HTTP+JSON',
+                protocol_version='0.3.0',
+            ),
+            AgentInterface(
+                url='http://complex.agent.example.com/grpc',
+                protocol_binding='GRPC',
+                protocol_version='0.3.0',
+            ),
+            AgentInterface(
+                url='http://complex.agent.example.com/jsonrpc',
+                protocol_binding='JSONRPC',
+                protocol_version='0.3.0',
+            ),
+        ],
+        security_requirements=[
+            SecurityRequirement(
+                schemes={
+                    'test_oauth': StringList(list=['read', 'write']),
+                    'test_api_key': StringList(),
+                }
+            ),
+            SecurityRequirement(schemes={'test_http': StringList()}),
+            SecurityRequirement(
+                schemes={'test_oidc': StringList(list=['openid', 'profile'])}
+            ),
+            SecurityRequirement(schemes={'test_mtls': StringList()}),
+        ],
+        security_schemes={
+            'test_oauth': SecurityScheme(
+                oauth2_security_scheme=OAuth2SecurityScheme(
+                    description='OAuth2 authentication',
+                    flows=OAuthFlows(
+                        authorization_code=AuthorizationCodeOAuthFlow(
+                            authorization_url='http://auth.example.com',
+                            token_url='http://token.example.com',
+                            scopes={
+                                'read': 'Read access',
+                                'write': 'Write access',
+                            },
+                        )
+                    ),
+                )
+            ),
+            'test_api_key': SecurityScheme(
+                api_key_security_scheme=APIKeySecurityScheme(
+                    description='API Key auth',
+                    location='header',
+                    name='X-API-KEY',
+                )
+            ),
+            'test_http': SecurityScheme(
+                http_auth_security_scheme=HTTPAuthSecurityScheme(
+                    description='HTTP Basic auth',
+                    scheme='basic',
+                    bearer_format='JWT',
+                )
+            ),
+            'test_oidc': SecurityScheme(
+                open_id_connect_security_scheme=OpenIdConnectSecurityScheme(
+                    description='OIDC Auth',
+                    open_id_connect_url='https://example.com/.well-known/openid-configuration',
+                )
+            ),
+            'test_mtls': SecurityScheme(
+                mtls_security_scheme=MutualTlsSecurityScheme(
+                    description='mTLS Auth'
+                )
+            ),
+        },
+        skills=[
+            AgentSkill(
+                id='skill-1',
+                name='Complex Skill 1',
+                description='The first complex skill',
+                tags=['example', 'complex'],
+                input_modes=['application/json'],
+                output_modes=['application/json'],
+                security_requirements=[
+                    SecurityRequirement(schemes={'test_api_key': StringList()})
+                ],
+            ),
+            AgentSkill(
+                id='skill-2',
+                name='Complex Skill 2',
+                description='The second complex skill',
+                tags=['example2'],
+                security_requirements=[
+                    SecurityRequirement(
+                        schemes={'test_oidc': StringList(list=['openid'])}
+                    )
+                ],
+            ),
+        ],
+    )
+
+    # 2. Minimal card
+    minimal_card = AgentCard(
+        name='Minimal Agent',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://minimal.example.com',
+                protocol_binding='JSONRPC',
+                protocol_version='0.3.0',
+            )
+        ],
+    )
+
+    # 3. Serialize both
+    payload = {
+        'complex': json.dumps(agent_card_to_dict(complex_card)),
+        'minimal': json.dumps(agent_card_to_dict(minimal_card)),
+    }
+    payload_json = json.dumps(payload)
+
+    # 4. Feed it to the 0.3.24 SDK subprocess
+    result = subprocess.run(
+        [  # noqa: S607
+            'uv',
+            'run',
+            '--with',
+            'a2a-sdk==0.3.24',
+            '--no-project',
+            '--isolated',
+            'python',
+            'tests/integration/cross_version/validate_agent_cards_030.py',
+        ],
+        input=payload_json,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    # 5. Parse the response
+    payload_v030 = json.loads(result.stdout)
+    print(payload_v030['complex'])
+    cards_v030 = {
+        key: parse_agent_card(json.loads(card_json))
+        for key, card_json in payload_v030.items()
+    }
+
+    # 6. Validate the parsed cards from 0.3
+    def _remove_empty_capabilities(card):
+        if card['capabilities'] == {}:
+            card.pop('capabilities')
+        return card
+
+    assert _remove_empty_capabilities(
+        MessageToDict(cards_v030['minimal'])
+    ) == MessageToDict(minimal_card)
+    assert MessageToDict(cards_v030['complex']) == MessageToDict(complex_card)
+
+    # 7. Validate parsing of 1.0 cards with ParseDict
+    cards_v100 = {
+        key: ParseDict(
+            json.loads(card_json), AgentCard(), ignore_unknown_fields=True
+        )
+        for key, card_json in payload.items()
+    }
+    assert _remove_empty_capabilities(
+        MessageToDict(cards_v100['minimal'])
+    ) == MessageToDict(minimal_card)
+    assert MessageToDict(cards_v100['complex']) == MessageToDict(complex_card)
diff --git a/tests/integration/cross_version/validate_agent_cards_030.py b/tests/integration/cross_version/validate_agent_cards_030.py
new file mode 100644
index 000000000..23a39a4c0
--- /dev/null
+++ b/tests/integration/cross_version/validate_agent_cards_030.py
@@ -0,0 +1,161 @@
+"""This is a script used by test_cross_version_card_validation.py.
+
+It is run in a subprocess with a SDK version 0.3.
+Steps:
+1. Read the serialized JSON payload from stdin.
+2. Validate the AgentCards with 0.3.24.
+3. Print re-serialized AgentCards to stdout.
+"""
+
+import json
+import sys
+
+from a2a.types import (
+    APIKeySecurityScheme,
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    AuthorizationCodeOAuthFlow,
+    HTTPAuthSecurityScheme,
+    MutualTLSSecurityScheme,
+    OAuth2SecurityScheme,
+    OAuthFlows,
+    OpenIdConnectSecurityScheme,
+)
+
+
+def validate_complex_card(card: AgentCard) -> None:
+    expected_card = AgentCard(
+        name='Complex Agent 0.3',
+        description='A very complex agent from 0.3.0',
+        version='1.5.2',
+        protocolVersion='0.3.0',
+        supportsAuthenticatedExtendedCard=True,
+        capabilities=AgentCapabilities(streaming=True, pushNotifications=True),
+        url='http://complex.agent.example.com/api',
+        preferredTransport='HTTP+JSON',
+        additionalInterfaces=[
+            AgentInterface(
+                url='http://complex.agent.example.com/grpc',
+                transport='GRPC',
+            ),
+            AgentInterface(
+                url='http://complex.agent.example.com/jsonrpc',
+                transport='JSONRPC',
+            ),
+        ],
+        defaultInputModes=['text/plain', 'application/json'],
+        defaultOutputModes=['application/json', 'image/png'],
+        security=[
+            {'test_oauth': ['read', 'write'], 'test_api_key': []},
+            {'test_http': []},
+            {'test_oidc': ['openid', 'profile']},
+            {'test_mtls': []},
+        ],
+        securitySchemes={
+            'test_oauth': OAuth2SecurityScheme(
+                type='oauth2',
+                description='OAuth2 authentication',
+                flows=OAuthFlows(
+                    authorizationCode=AuthorizationCodeOAuthFlow(
+                        authorizationUrl='http://auth.example.com',
+                        tokenUrl='http://token.example.com',
+                        scopes={
+                            'read': 'Read access',
+                            'write': 'Write access',
+                        },
+                    )
+                ),
+            ),
+            'test_api_key': APIKeySecurityScheme(
+                type='apiKey',
+                description='API Key auth',
+                in_='header',
+                name='X-API-KEY',
+            ),
+            'test_http': HTTPAuthSecurityScheme(
+                type='http',
+                description='HTTP Basic auth',
+                scheme='basic',
+                bearerFormat='JWT',
+            ),
+            'test_oidc': OpenIdConnectSecurityScheme(
+                type='openIdConnect',
+                description='OIDC Auth',
+                openIdConnectUrl='https://example.com/.well-known/openid-configuration',
+            ),
+            'test_mtls': MutualTLSSecurityScheme(
+                type='mutualTLS', description='mTLS Auth'
+            ),
+        },
+        skills=[
+            AgentSkill(
+                id='skill-1',
+                name='Complex Skill 1',
+                description='The first complex skill',
+                tags=['example', 'complex'],
+                inputModes=['application/json'],
+                outputModes=['application/json'],
+                security=[{'test_api_key': []}],
+            ),
+            AgentSkill(
+                id='skill-2',
+                name='Complex Skill 2',
+                description='The second complex skill',
+                tags=['example2'],
+                security=[{'test_oidc': ['openid']}],
+            ),
+        ],
+    )
+
+    assert card == expected_card
+
+
+def validate_minimal_card(card: AgentCard) -> None:
+    expected_card = AgentCard(
+        name='Minimal Agent',
+        description='',
+        version='',
+        protocolVersion='0.3.0',
+        capabilities=AgentCapabilities(),
+        url='http://minimal.example.com',
+        preferredTransport='JSONRPC',
+        defaultInputModes=[],
+        defaultOutputModes=[],
+        skills=[],
+    )
+
+    assert card == expected_card
+
+
+def main() -> None:
+    # Read the serialized JSON payload from stdin
+    input_text = sys.stdin.read().strip()
+    if not input_text:
+        sys.exit(1)
+
+    try:
+        input_dict = json.loads(input_text)
+
+        complex_card = AgentCard.model_validate_json(input_dict['complex'])
+        validate_complex_card(complex_card)
+
+        minimal_card = AgentCard.model_validate_json(input_dict['minimal'])
+        validate_minimal_card(minimal_card)
+
+        payload = {
+            'complex': complex_card.model_dump_json(),
+            'minimal': minimal_card.model_dump_json(),
+        }
+        print(json.dumps(payload))
+
+    except Exception as e:
+        print(
+            f'Failed to validate AgentCards with 0.3.24: {e}', file=sys.stderr
+        )
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/integration/push_notifications/__init__.py b/tests/integration/push_notifications/__init__.py
new file mode 100644
index 000000000..b75e37d3d
--- /dev/null
+++ b/tests/integration/push_notifications/__init__.py
@@ -0,0 +1,3 @@
+# Copyright 2025 Google LLC
+# SPDX-License-Identifier: Apache-2.0
+"""Push notifications e2e tests package."""
diff --git a/tests/integration/push_notifications/agent_app.py b/tests/integration/push_notifications/agent_app.py
new file mode 100644
index 000000000..127ee9d1e
--- /dev/null
+++ b/tests/integration/push_notifications/agent_app.py
@@ -0,0 +1,242 @@
+import httpx
+
+from a2a.auth.user import UnauthenticatedUser, User
+from a2a.helpers.proto_helpers import (
+    new_task_from_user_message,
+    new_text_message,
+)
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes
+from a2a.server.routes.common import DefaultServerCallContextBuilder
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks import (
+    BasePushNotificationSender,
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+    TaskUpdater,
+)
+from a2a.types import InvalidParamsError
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Message,
+    Task,
+)
+from starlette.applications import Starlette
+from starlette.requests import Request
+
+
+_TEST_USER_HEADER = 'x-test-user'
+
+
+def test_agent_card(url: str) -> AgentCard:
+    """Returns an agent card for the test agent."""
+    return AgentCard(
+        name='Test Agent',
+        description='Just a test agent',
+        version='1.0.0',
+        default_input_modes=['text'],
+        default_output_modes=['text'],
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            extended_agent_card=True,
+        ),
+        skills=[
+            AgentSkill(
+                id='greeting',
+                name='Greeting Agent',
+                description='just greets the user',
+                tags=['greeting'],
+                examples=['Hello Agent!', 'How are you?'],
+            )
+        ],
+        supported_interfaces=[
+            AgentInterface(
+                url=url,
+                protocol_binding='HTTP+JSON',
+            )
+        ],
+    )
+
+
+class TestAgent:
+    """Agent for push notification testing."""
+
+    async def invoke(
+        self, updater: TaskUpdater, msg: Message, task: Task
+    ) -> None:
+        # Fail for unsupported messages.
+        if (
+            not msg.parts
+            or len(msg.parts) != 1
+            or not msg.parts[0].HasField('text')
+        ):
+            await updater.failed(
+                new_text_message(
+                    'Unsupported message.', task.context_id, task.id
+                )
+            )
+            return
+        text_message = msg.parts[0].text
+
+        # Simple request-response flow.
+        if text_message == 'Hello Agent!':
+            await updater.complete(
+                new_text_message('Hello User!', task.context_id, task.id)
+            )
+
+        # Flow with user input required: "How are you?" -> "Good! How are you?" -> "Good" -> "Amazing".
+        elif text_message == 'How are you?':
+            await updater.requires_input(
+                new_text_message('Good! How are you?', task.context_id, task.id)
+            )
+        elif text_message == 'Good':
+            await updater.complete(
+                new_text_message('Amazing', task.context_id, task.id)
+            )
+
+        # Fail for unsupported messages.
+        else:
+            await updater.failed(
+                new_text_message(
+                    'Unsupported message.', task.context_id, task.id
+                )
+            )
+
+
+class TestAgentExecutor(AgentExecutor):
+    """Test AgentExecutor implementation."""
+
+    def __init__(self) -> None:
+        self.agent = TestAgent()
+
+    async def execute(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ) -> None:
+        if not context.message:
+            raise InvalidParamsError(message='No message')
+
+        task = context.current_task
+        if not task:
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+
+        await self.agent.invoke(updater, context.message, task)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        raise NotImplementedError('cancel not supported')
+
+
+def create_agent_app(
+    url: str, notification_client: httpx.AsyncClient
+) -> Starlette:
+    """Creates a new HTTP+REST Starlette application for the test agent."""
+    push_config_store = InMemoryPushNotificationConfigStore()
+    card = test_agent_card(url)
+    extended_card = test_agent_card(url)
+    extended_card.name = 'Test Agent Extended'
+    handler = DefaultRequestHandler(
+        agent_executor=TestAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=card,
+        extended_agent_card=extended_card,
+        push_config_store=push_config_store,
+        push_sender=BasePushNotificationSender(
+            httpx_client=notification_client,
+            config_store=push_config_store,
+        ),
+        # e2e webhooks are real local test servers (loopback).
+        push_url_validator=None,
+    )
+    rest_routes = create_rest_routes(request_handler=handler)
+    agent_card_routes = create_agent_card_routes(
+        agent_card=card, card_url='/.well-known/agent-card.json'
+    )
+    return Starlette(routes=[*rest_routes, *agent_card_routes])
+
+
+class _NamedTestUser(User):
+    """Authenticated test user identified by ``user_name``."""
+
+    def __init__(self, user_name: str) -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+class _HeaderUserContextBuilder(DefaultServerCallContextBuilder):
+    """Builds a ServerCallContext whose user is read from a request header."""
+
+    def build_user(self, request: Request) -> User:
+        user_name = request.headers.get(_TEST_USER_HEADER)
+        if user_name:
+            return _NamedTestUser(user_name)
+        return UnauthenticatedUser()
+
+
+def create_multi_user_agent_app(
+    url: str, notification_client: httpx.AsyncClient
+) -> Starlette:
+    """Creates a multi-user variant of the test agent app.
+
+    Differences from create_agent_app:
+
+    - Identity is read from the x-test-user header on each request
+      via _HeaderUserContextBuilder. Multiple authenticated
+      users (e.g. alice, bob) can therefore call the same
+      server.
+    - The InMemoryTaskStore uses a constant owner resolver, so
+      every authenticated user has access to every task.
+    - The InMemoryPushNotificationConfigStore keeps the default
+      per-user owner resolver, so each registrar's configs live in their
+      own owner partition; this exercises cross-owner aggregation in
+      get_info_for_dispatch.
+    """
+    # Shared task visibility: any authenticated user can see any task.
+    task_store = InMemoryTaskStore(owner_resolver=lambda _ctx: 'shared')
+
+    # Per-user push-config partitioning (the default).
+    push_config_store = InMemoryPushNotificationConfigStore()
+
+    card = test_agent_card(url)
+    extended_card = test_agent_card(url)
+    extended_card.name = 'Test Agent Extended'
+
+    handler = DefaultRequestHandler(
+        agent_executor=TestAgentExecutor(),
+        task_store=task_store,
+        agent_card=card,
+        extended_agent_card=extended_card,
+        push_config_store=push_config_store,
+        push_sender=BasePushNotificationSender(
+            httpx_client=notification_client,
+            config_store=push_config_store,
+        ),
+        # e2e webhooks are real local test servers (loopback).
+        push_url_validator=None,
+    )
+
+    rest_routes = create_rest_routes(
+        request_handler=handler,
+        context_builder=_HeaderUserContextBuilder(),
+    )
+    agent_card_routes = create_agent_card_routes(
+        agent_card=card, card_url='/.well-known/agent-card.json'
+    )
+    return Starlette(routes=[*rest_routes, *agent_card_routes])
diff --git a/tests/integration/push_notifications/notifications_app.py b/tests/integration/push_notifications/notifications_app.py
new file mode 100644
index 000000000..bac1b9bb0
--- /dev/null
+++ b/tests/integration/push_notifications/notifications_app.py
@@ -0,0 +1,88 @@
+import asyncio
+
+from typing import Annotated, Any
+
+from a2a.types.a2a_pb2 import StreamResponse
+from fastapi import FastAPI, HTTPException, Path, Request
+from google.protobuf.json_format import MessageToDict, ParseDict
+from pydantic import BaseModel
+
+
+class Notification(BaseModel):
+    """Encapsulates default push notification data."""
+
+    event: dict[str, Any]
+    token: str
+
+
+def create_notifications_app() -> FastAPI:
+    """Creates a simple push notification ingesting HTTP+REST application."""
+    app = FastAPI()
+    store_lock = asyncio.Lock()
+    store: dict[str, list[Notification]] = {}
+
+    @app.post('/notifications')
+    async def add_notification(request: Request):
+        """Endpoint for ingesting notifications from agents. It receives a JSON
+        payload and stores it in-memory.
+        """
+        token = request.headers.get('x-a2a-notification-token')
+        if not token:
+            raise HTTPException(
+                status_code=400,
+                detail='Missing "x-a2a-notification-token" header.',
+            )
+        try:
+            json_data = await request.json()
+            stream_response = ParseDict(json_data, StreamResponse())
+
+            payload_name = stream_response.WhichOneof('payload')
+            task_id = None
+            if payload_name:
+                event_payload = getattr(stream_response, payload_name)
+                # The 'Task' message uses 'id', while event messages use 'task_id'.
+                task_id = getattr(
+                    event_payload, 'task_id', getattr(event_payload, 'id', None)
+                )
+
+            if not task_id:
+                raise HTTPException(
+                    status_code=400,
+                    detail='Missing "task_id" in push notification.',
+                )
+
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+        async with store_lock:
+            if task_id not in store:
+                store[task_id] = []
+            store[task_id].append(
+                Notification(
+                    event=MessageToDict(
+                        stream_response, preserving_proto_field_name=True
+                    ),
+                    token=token,
+                )
+            )
+        return {
+            'status': 'received',
+        }
+
+    @app.get('/{task_id}/notifications')
+    async def list_notifications_by_task(
+        task_id: Annotated[
+            str, Path(title='The ID of the task to list the notifications for.')
+        ],
+    ):
+        """Helper endpoint for retrieving ingested notifications for a given task."""
+        async with store_lock:
+            notifications = store.get(task_id, [])
+        return {'notifications': notifications}
+
+    @app.get('/health')
+    def health_check():
+        """Helper endpoint for checking if the server is up."""
+        return {'status': 'ok'}
+
+    return app
diff --git a/tests/integration/push_notifications/test_default_push_notification_support.py b/tests/integration/push_notifications/test_default_push_notification_support.py
new file mode 100644
index 000000000..eb7928ba9
--- /dev/null
+++ b/tests/integration/push_notifications/test_default_push_notification_support.py
@@ -0,0 +1,565 @@
+import asyncio
+import time
+import uuid
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.client import (
+    ClientConfig,
+    ClientFactory,
+    minimal_agent_card,
+)
+from a2a.types.a2a_pb2 import (
+    ListTaskPushNotificationConfigsRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    TaskPushNotificationConfig,
+    TaskState,
+)
+from a2a.utils.constants import TransportProtocol
+
+from .agent_app import create_agent_app, create_multi_user_agent_app
+from .notifications_app import Notification, create_notifications_app
+from .utils import (
+    create_app_process,
+    find_free_port,
+    wait_for_server_ready,
+)
+
+
+_TEST_USER_HEADER = 'x-test-user'
+
+
+@pytest.fixture(scope='module')
+def notifications_server():
+    """
+    Starts a simple push notifications ingesting server and yields its URL.
+    """
+    host = '127.0.0.1'
+    port = find_free_port()
+    url = f'http://{host}:{port}'
+
+    process = create_app_process(create_notifications_app(), host, port)
+    process.start()
+    try:
+        wait_for_server_ready(f'{url}/health')
+    except TimeoutError as e:
+        process.terminate()
+        raise e
+
+    yield url
+
+    process.terminate()
+    process.join()
+
+
+@pytest_asyncio.fixture(scope='module')
+async def notifications_client():
+    """An async client fixture for calling the notifications server."""
+    async with httpx.AsyncClient() as client:
+        yield client
+
+
+@pytest.fixture(scope='module')
+def agent_server(notifications_client: httpx.AsyncClient):
+    """Starts a test agent server and yields its URL."""
+    host = '127.0.0.1'
+    port = find_free_port()
+    url = f'http://{host}:{port}'
+
+    process = create_app_process(
+        create_agent_app(url, notifications_client), host, port
+    )
+    process.start()
+    try:
+        wait_for_server_ready(
+            f'{url}/extendedAgentCard', headers={'A2A-Version': '1.0'}
+        )
+    except TimeoutError as e:
+        process.terminate()
+        raise e
+
+    yield url
+
+    process.terminate()
+    process.join()
+
+
+@pytest.fixture(scope='module')
+def multi_user_agent_server(notifications_client: httpx.AsyncClient):
+    """Starts the multi-user variant of the test agent server.
+
+    This variant reads identity from an x-test-user request header
+    and uses a TaskStore whose owner resolver returns a constant, so
+    every authenticated user can see every task. It runs on its own
+    port alongside the single-user agent_server fixture; the
+    notifications_server is shared (notifications include the
+    task_id and per-config token, so collisions are avoided).
+    """
+    host = '127.0.0.1'
+    port = find_free_port()
+    url = f'http://{host}:{port}'
+
+    process = create_app_process(
+        create_multi_user_agent_app(url, notifications_client), host, port
+    )
+    process.start()
+    try:
+        wait_for_server_ready(
+            f'{url}/extendedAgentCard',
+            headers={'A2A-Version': '1.0', _TEST_USER_HEADER: 'health-check'},
+        )
+    except TimeoutError as e:
+        process.terminate()
+        raise e
+
+    yield url
+
+    process.terminate()
+    process.join()
+
+
+@pytest_asyncio.fixture(scope='function')
+async def http_client():
+    """An async client fixture for test functions."""
+    async with httpx.AsyncClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_notification_triggering_with_in_message_config_e2e(
+    notifications_server: str,
+    agent_server: str,
+    http_client: httpx.AsyncClient,
+):
+    """
+    Tests push notification triggering for in-message push notification config.
+    """
+    # Create an A2A client with a push notification config.
+    token = uuid.uuid4().hex
+    a2a_client = ClientFactory(
+        ClientConfig(
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+            push_notification_config=TaskPushNotificationConfig(
+                id='in-message-config',
+                url=f'{notifications_server}/notifications',
+                token=token,
+            ),
+        )
+    ).create(minimal_agent_card(agent_server, [TransportProtocol.HTTP_JSON]))
+
+    # Send a message and extract the returned task.
+    responses = [
+        response
+        async for response in a2a_client.send_message(
+            SendMessageRequest(
+                message=Message(
+                    message_id='hello-agent',
+                    parts=[Part(text='Hello Agent!')],
+                    role=Role.ROLE_USER,
+                )
+            )
+        )
+    ]
+    assert len(responses) == 1
+    stream_response = responses[0]
+    assert stream_response.HasField('task')
+    task = stream_response.task
+
+    # Verify a single notification was sent.
+    notifications = await wait_for_n_notifications(
+        http_client,
+        f'{notifications_server}/{task.id}/notifications',
+        n=2,
+    )
+    assert notifications[0].token == token
+
+    # Verify exactly two consecutive events: SUBMITTED -> COMPLETED
+    assert len(notifications) == 2
+
+    # 1. First event: SUBMITTED (Task)
+    event0 = notifications[0].event
+    state0 = event0['task'].get('status', {}).get('state')
+    assert state0 == 'TASK_STATE_SUBMITTED'
+
+    # 2. Second event: COMPLETED (TaskStatusUpdateEvent)
+    event1 = notifications[1].event
+    state1 = event1['status_update'].get('status', {}).get('state')
+    assert state1 == 'TASK_STATE_COMPLETED'
+
+
+@pytest.mark.asyncio
+async def test_notification_triggering_after_config_change_e2e(
+    notifications_server: str, agent_server: str, http_client: httpx.AsyncClient
+):
+    """
+    Tests notification triggering after setting the push notification config in a separate call.
+    """
+    # Configure an A2A client without a push notification config.
+    a2a_client = ClientFactory(
+        ClientConfig(
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+    ).create(minimal_agent_card(agent_server, [TransportProtocol.HTTP_JSON]))
+
+    # Send a message and extract the returned task.
+    responses = [
+        response
+        async for response in a2a_client.send_message(
+            SendMessageRequest(
+                message=Message(
+                    message_id='how-are-you',
+                    parts=[Part(text='How are you?')],
+                    role=Role.ROLE_USER,
+                ),
+                configuration=SendMessageConfiguration(),
+            )
+        )
+    ]
+    assert len(responses) == 1
+    stream_response = responses[0]
+    assert stream_response.HasField('task')
+    task = stream_response.task
+    assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    # Verify that no notification has been sent yet.
+    response = await http_client.get(
+        f'{notifications_server}/{task.id}/notifications'
+    )
+    assert response.status_code == 200
+    assert len(response.json().get('notifications', [])) == 0
+
+    # Set the push notification config.
+    token = uuid.uuid4().hex
+    await a2a_client.create_task_push_notification_config(
+        TaskPushNotificationConfig(
+            task_id=f'{task.id}',
+            id='after-config-change',
+            url=f'{notifications_server}/notifications',
+            token=token,
+        )
+    )
+
+    # Send another message that should trigger a push notification.
+    responses = [
+        response
+        async for response in a2a_client.send_message(
+            SendMessageRequest(
+                message=Message(
+                    task_id=task.id,
+                    message_id='good',
+                    parts=[Part(text='Good')],
+                    role=Role.ROLE_USER,
+                ),
+                configuration=SendMessageConfiguration(),
+            )
+        )
+    ]
+    assert len(responses) == 1
+
+    # Verify that the push notification was sent.
+    notifications = await wait_for_n_notifications(
+        http_client,
+        f'{notifications_server}/{task.id}/notifications',
+        n=1,
+    )
+    event = notifications[0].event
+    state = event['status_update'].get('status', {}).get('state', '')
+    assert state == 'TASK_STATE_COMPLETED'
+    assert notifications[0].token == token
+
+
+@pytest.mark.asyncio
+async def test_multi_registrar_fan_out_e2e(
+    notifications_server: str,
+    agent_server: str,
+    http_client: httpx.AsyncClient,
+):
+    """Two pushNotificationConfigs registered for the same task both fire end-to-end.
+
+    Exercises the dispatch fan-out across multiple registered configs
+    over the real wire: each registered URL must receive a POST with
+    its own token in the X-A2A-Notification-Token header.
+    """
+    # Configure an A2A client without a per-message push notification config
+    # (we'll register configs explicitly after the task is created).
+    a2a_client = ClientFactory(
+        ClientConfig(
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+    ).create(minimal_agent_card(agent_server, [TransportProtocol.HTTP_JSON]))
+
+    # Send an initial message that requires more input, so the task lingers
+    # long enough for us to register multiple push configs against it.
+    responses = [
+        response
+        async for response in a2a_client.send_message(
+            SendMessageRequest(
+                message=Message(
+                    message_id='multi-fanout-init',
+                    parts=[Part(text='How are you?')],
+                    role=Role.ROLE_USER,
+                ),
+                configuration=SendMessageConfiguration(),
+            )
+        )
+    ]
+    assert len(responses) == 1
+    stream_response = responses[0]
+    assert stream_response.HasField('task')
+    task = stream_response.task
+    assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    # Register two distinct push configs for the same task. Both share the
+    # same registrar (this client), but use different config ids, URLs, and
+    # tokens. Both must fire when the next event is dispatched.
+    token_a = uuid.uuid4().hex
+    token_b = uuid.uuid4().hex
+    await a2a_client.create_task_push_notification_config(
+        TaskPushNotificationConfig(
+            task_id=task.id,
+            id='registrar-a',
+            url=f'{notifications_server}/notifications',
+            token=token_a,
+        )
+    )
+    await a2a_client.create_task_push_notification_config(
+        TaskPushNotificationConfig(
+            task_id=task.id,
+            id='registrar-b',
+            url=f'{notifications_server}/notifications',
+            token=token_b,
+        )
+    )
+
+    # Sanity: no notifications have fired yet.
+    response = await http_client.get(
+        f'{notifications_server}/{task.id}/notifications'
+    )
+    assert response.status_code == 200
+    assert len(response.json().get('notifications', [])) == 0
+
+    # Send a follow-up message that completes the task and triggers
+    # dispatch. Both registered configs must receive a POST.
+    responses = [
+        response
+        async for response in a2a_client.send_message(
+            SendMessageRequest(
+                message=Message(
+                    task_id=task.id,
+                    message_id='multi-fanout-complete',
+                    parts=[Part(text='Good')],
+                    role=Role.ROLE_USER,
+                ),
+                configuration=SendMessageConfiguration(),
+            )
+        )
+    ]
+    assert len(responses) == 1
+
+    # Expect 2 notifications: one COMPLETED event, fanned out to 2 configs.
+    notifications = await wait_for_n_notifications(
+        http_client,
+        f'{notifications_server}/{task.id}/notifications',
+        n=2,
+    )
+
+    # Both tokens must appear exactly once.
+    received_tokens = sorted(n.token for n in notifications)
+    assert received_tokens == sorted([token_a, token_b])
+
+    # Both notifications must carry the same COMPLETED event payload.
+    for notification in notifications:
+        state = (
+            notification.event.get('status_update', {})
+            .get('status', {})
+            .get('state')
+        )
+        assert state == 'TASK_STATE_COMPLETED'
+
+
+def _make_user_a2a_client(agent_server: str, user_name: str):
+    """Builds an A2A client that identifies as user_name on every request.
+
+    Identity is conveyed via a default header on the underlying
+    httpx.AsyncClient; the multi-user agent app's context builder
+    reads that header to populate ServerCallContext.user.
+    """
+    httpx_client = httpx.AsyncClient(headers={_TEST_USER_HEADER: user_name})
+    return ClientFactory(
+        ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+    ).create(
+        minimal_agent_card(agent_server, [TransportProtocol.HTTP_JSON])
+    ), httpx_client
+
+
+@pytest.mark.asyncio
+async def test_alice_and_bob_both_receive_notifications_on_shared_task_e2e(
+    notifications_server: str,
+    multi_user_agent_server: str,
+    http_client: httpx.AsyncClient,
+):
+    """Alice registers a webhook; Bob registers a webhook; both fire end-to-end.
+
+    1. Alice creates a task (it lingers in INPUT_REQUIRED).
+    2. Alice registers her own push config on the task.
+    3. Bob (a different authenticated user, sharing access to the task)
+       registers his own push config on the same task.
+    4. Bob (the dispatcher, *not* the registrar of Alice's webhook)
+       sends a follow-up message that completes the task.
+    5. Both Alice's webhook and Bob's webhook receive a POST with their
+       own respective tokens.
+
+    Regression guard for the design's central guarantee: subscriptions
+    fire on the registrar's behalf regardless of which user's action
+    triggered the event. A regression that re-introduced
+    dispatcher-context filtering on the dispatch path would drop one of
+    the two notifications.
+    """
+    alice_client, alice_http = _make_user_a2a_client(
+        multi_user_agent_server, 'alice'
+    )
+    bob_client, bob_http = _make_user_a2a_client(multi_user_agent_server, 'bob')
+
+    try:
+        responses = [
+            response
+            async for response in alice_client.send_message(
+                SendMessageRequest(
+                    message=Message(
+                        message_id='shared-task-init',
+                        parts=[Part(text='How are you?')],
+                        role=Role.ROLE_USER,
+                    ),
+                )
+            )
+        ]
+        assert len(responses) == 1
+        assert responses[0].HasField('task')
+        task = responses[0].task
+        assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+        # 2. Alice registers her push config.
+        alice_token = uuid.uuid4().hex
+        await alice_client.create_task_push_notification_config(
+            TaskPushNotificationConfig(
+                task_id=task.id,
+                id='alice-cfg',
+                url=f'{notifications_server}/notifications',
+                token=alice_token,
+            )
+        )
+
+        # 3. Bob registers his push config on the same task.
+        bob_token = uuid.uuid4().hex
+        await bob_client.create_task_push_notification_config(
+            TaskPushNotificationConfig(
+                task_id=task.id,
+                id='bob-cfg',
+                url=f'{notifications_server}/notifications',
+                token=bob_token,
+            )
+        )
+
+        # Sanity: the per-user listing endpoints are owner-scoped --
+        # Alice does not see Bob's config and vice-versa, even though
+        # both can see the underlying task.
+        #
+        # The auto-registered empty config (see step 1 quirk note) lives
+        # in Alice's partition under ``id == task_id``, so Alice's
+        # listing contains ``{'alice-cfg', task.id}``; the key invariant
+        # is that neither listing contains the other user's id or
+        # token.
+        alice_configs = await alice_client.list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id=task.id)
+        )
+        alice_ids = {c.id for c in alice_configs.configs}
+        assert 'alice-cfg' in alice_ids
+        assert 'bob-cfg' not in alice_ids
+        assert all(c.token != bob_token for c in alice_configs.configs)
+
+        bob_configs = await bob_client.list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id=task.id)
+        )
+        bob_ids = {c.id for c in bob_configs.configs}
+        assert 'bob-cfg' in bob_ids
+        assert 'alice-cfg' not in bob_ids
+        assert all(c.token != alice_token for c in bob_configs.configs)
+
+        # Sanity: no notifications have fired yet.
+        response = await http_client.get(
+            f'{notifications_server}/{task.id}/notifications'
+        )
+        assert response.status_code == 200
+        assert len(response.json().get('notifications', [])) == 0
+
+        # 4. Bob sends the follow-up message that completes the task.
+        # Omit ``configuration`` for the same reason as step 1.
+        responses = [
+            response
+            async for response in bob_client.send_message(
+                SendMessageRequest(
+                    message=Message(
+                        task_id=task.id,
+                        message_id='shared-task-complete',
+                        parts=[Part(text='Good')],
+                        role=Role.ROLE_USER,
+                    ),
+                )
+            )
+        ]
+        assert len(responses) == 1
+
+        # 5. Both Alice's and Bob's webhooks receive the COMPLETED event.
+        notifications = await wait_for_n_notifications(
+            http_client,
+            f'{notifications_server}/{task.id}/notifications',
+            n=2,
+        )
+
+        received_tokens = sorted(n.token for n in notifications)
+        assert received_tokens == sorted([alice_token, bob_token])
+
+        for notification in notifications:
+            state = (
+                notification.event.get('status_update', {})
+                .get('status', {})
+                .get('state')
+            )
+            assert state == 'TASK_STATE_COMPLETED'
+    finally:
+        await alice_http.aclose()
+        await bob_http.aclose()
+
+
+async def wait_for_n_notifications(
+    http_client: httpx.AsyncClient,
+    url: str,
+    n: int,
+    timeout: int = 3,
+) -> list[Notification]:
+    """
+    Queries the notification URL until the desired number of notifications
+    is received or the timeout is reached.
+    """
+    start_time = time.time()
+    notifications = []
+    while True:
+        response = await http_client.get(url)
+        assert response.status_code == 200
+        notifications = response.json()['notifications']
+        if len(notifications) == n:
+            return [Notification.model_validate(n) for n in notifications]
+        if time.time() - start_time > timeout:
+            raise TimeoutError(
+                f'Notification retrieval timed out. Got {len(notifications)} notification(s), want {n}. Retrieved notifications: {notifications}.'
+            )
+        await asyncio.sleep(0.1)
diff --git a/tests/integration/push_notifications/utils.py b/tests/integration/push_notifications/utils.py
new file mode 100644
index 000000000..a7317f1b2
--- /dev/null
+++ b/tests/integration/push_notifications/utils.py
@@ -0,0 +1,57 @@
+import contextlib
+import multiprocessing
+import socket
+import sys
+import time
+
+import httpx
+import uvicorn
+
+
+def find_free_port():
+    """Finds and returns an available ephemeral localhost port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def run_server(app, host, port) -> None:
+    """Runs a uvicorn server."""
+    uvicorn.run(app, host=host, port=port, log_level='warning')
+
+
+def wait_for_server_ready(
+    url: str, timeout: int = 10, headers: dict | None = None
+) -> None:
+    """Polls the provided URL endpoint until the server is up."""
+    start_time = time.time()
+    while True:
+        with contextlib.suppress(httpx.ConnectError):
+            with httpx.Client(headers=headers) as client:
+                response = client.get(url)
+                if response.status_code == 200:
+                    return
+        if time.time() - start_time > timeout:
+            raise TimeoutError(
+                f'Server at {url} failed to start after {timeout}s'
+            )
+        time.sleep(0.1)
+
+
+def create_app_process(app, host, port) -> 'Any':  # type: ignore[name-defined]
+    """Creates a separate process for a given application.
+
+    Uses 'fork' context on non-Windows platforms to avoid pickle issues
+    with FastAPI apps (which have closures that can't be pickled).
+    """
+    # Use fork on Unix-like systems to avoid pickle issues with FastAPI
+    if sys.platform != 'win32':
+        ctx = multiprocessing.get_context('fork')
+    else:
+        ctx = multiprocessing.get_context('spawn')
+
+    return ctx.Process(
+        target=run_server,
+        args=(app, host, port),
+        daemon=True,
+    )
diff --git a/tests/integration/test_agent_card.py b/tests/integration/test_agent_card.py
new file mode 100644
index 000000000..9cc6b142a
--- /dev/null
+++ b/tests/integration/test_agent_card.py
@@ -0,0 +1,133 @@
+import httpx
+import pytest
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+)
+from a2a.utils.constants import VERSION_HEADER, TransportProtocol
+from fastapi import FastAPI
+from starlette.applications import Starlette
+
+
+class DummyAgentExecutor(AgentExecutor):
+    """An agent executor that does nothing for integration testing."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('header_val', [None, '0.3', '1.0', '1.2', 'INVALID'])
+async def test_agent_card_integration(header_val: str | None) -> None:
+    """Tests that the agent card is correctly served via REST and JSONRPC."""
+    # 1. Define AgentCard
+    agent_card = AgentCard(
+        name='Test Agent',
+        description='An agent for testing agent card serving.',
+        version='1.0.0',
+        capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://localhost/jsonrpc/',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url='http://localhost/rest/',
+            ),
+        ],
+    )
+
+    # 2. Setup Server
+    task_store = InMemoryTaskStore()
+    handler = DefaultRequestHandler(
+        agent_executor=DummyAgentExecutor(),
+        task_store=task_store,
+        agent_card=agent_card,
+        queue_manager=InMemoryQueueManager(),
+        push_config_store=InMemoryPushNotificationConfigStore(),
+    )
+    app = FastAPI()
+
+    # Mount JSONRPC application
+    jsonrpc_routes = [
+        *create_agent_card_routes(
+            agent_card=agent_card, card_url='/.well-known/agent-card.json'
+        ),
+        *create_jsonrpc_routes(request_handler=handler, rpc_url='/'),
+    ]
+    jsonrpc_app = Starlette(routes=jsonrpc_routes)
+    app.mount('/jsonrpc', jsonrpc_app)
+
+    rest_routes = [
+        *create_agent_card_routes(
+            agent_card=agent_card, card_url='/.well-known/agent-card.json'
+        ),
+        *create_rest_routes(request_handler=handler),
+    ]
+    rest_app = Starlette(routes=rest_routes)
+    app.mount('/rest', rest_app)
+
+    expected_content = {
+        'name': 'Test Agent',
+        'description': 'An agent for testing agent card serving.',
+        'supportedInterfaces': [
+            {'url': 'http://localhost/jsonrpc/', 'protocolBinding': 'JSONRPC'},
+            {'url': 'http://localhost/rest/', 'protocolBinding': 'HTTP+JSON'},
+        ],
+        'version': '1.0.0',
+        'capabilities': {'streaming': True, 'pushNotifications': True},
+        'defaultInputModes': ['text/plain'],
+        'defaultOutputModes': ['text/plain'],
+        'additionalInterfaces': [
+            {'transport': 'HTTP+JSON', 'url': 'http://localhost/rest/'}
+        ],
+        'preferredTransport': 'JSONRPC',
+        'protocolVersion': '0.3',
+        'skills': [],
+        'url': 'http://localhost/jsonrpc/',
+    }
+
+    headers = {}
+    if header_val is not None:
+        headers[VERSION_HEADER] = header_val
+
+    # 3. Use direct http client (ASGITransport) to fetch and assert
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url='http://testserver'
+    ) as client:
+        # Fetch from JSONRPC endpoint
+        resp_jsonrpc = await client.get(
+            '/jsonrpc/.well-known/agent-card.json', headers=headers
+        )
+        assert resp_jsonrpc.status_code == 200
+        assert resp_jsonrpc.json() == expected_content
+
+        # Fetch from REST endpoint
+        resp_rest = await client.get(
+            '/rest/.well-known/agent-card.json', headers=headers
+        )
+        assert resp_rest.status_code == 200
+        assert resp_rest.json() == expected_content
diff --git a/tests/integration/test_agent_card_signing_smoke.py b/tests/integration/test_agent_card_signing_smoke.py
new file mode 100644
index 000000000..90babfee8
--- /dev/null
+++ b/tests/integration/test_agent_card_signing_smoke.py
@@ -0,0 +1,67 @@
+"""End-to-end smoke test for `samples/agent_card_signing.py`.
+
+Runs the sample's demo mode as a subprocess, which serves a signed Agent Card
+and then verifies it, asserting that a genuine card is accepted and that
+tampered, unsigned and untrusted-key cards are all rejected.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import socket
+import sys
+
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SAMPLE_SCRIPT = REPO_ROOT / 'samples' / 'agent_card_signing.py'
+
+DEMO_TIMEOUT_S = 60.0
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(('127.0.0.1', 0))
+        return sock.getsockname()[1]
+
+
+async def _run_demo() -> str:
+    """Run the sample in demo mode on a free port and return its output."""
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(SAMPLE_SCRIPT),
+        'demo',
+        '--port',
+        str(_free_port()),
+        cwd=str(REPO_ROOT),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(
+            proc.communicate(), timeout=DEMO_TIMEOUT_S
+        )
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise
+
+    output = stdout.decode('utf-8', errors='replace')
+    assert proc.returncode == 0, (
+        f'Sample exited with {proc.returncode}.\nOutput:\n{output}'
+    )
+    return output
+
+
+@pytest.mark.asyncio
+async def test_agent_card_signing_demo() -> None:
+    """The sample should verify its own card and reject the forged ones."""
+    output = await _run_demo()
+
+    assert 'verified card for agent: Signed Card Agent' in output, output
+    # One rejection each for the tampered, unsigned and untrusted-key cards.
+    assert output.count('rejected as expected') == 3, output
+    assert 'ERROR:' not in output, output
diff --git a/tests/integration/test_client_server_integration.py b/tests/integration/test_client_server_integration.py
new file mode 100644
index 000000000..ea093aa7e
--- /dev/null
+++ b/tests/integration/test_client_server_integration.py
@@ -0,0 +1,1341 @@
+import asyncio
+
+from collections.abc import AsyncGenerator
+from typing import Any, NamedTuple
+from unittest.mock import ANY, AsyncMock, patch
+
+import grpc
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.client import Client, ClientConfig
+from a2a.client.base_client import BaseClient
+from a2a.client.card_resolver import A2ACardResolver
+from a2a.client.client import ClientCallContext
+from a2a.client.client_factory import ClientFactory
+from a2a.client.service_parameters import (
+    ServiceParametersFactory,
+    with_a2a_extensions,
+)
+from a2a.client.transports import JsonRpcTransport, RestTransport
+
+# Compat v0.3 imports for dedicated tests
+from a2a.compat.v0_3 import a2a_v0_3_pb2_grpc
+from a2a.compat.v0_3.grpc_handler import CompatGrpcHandler
+from a2a.server.request_handlers import GrpcHandler, RequestHandler
+from a2a.server.request_handlers.default_request_handler import (
+    LegacyRequestHandler,
+)
+from a2a.server.routes import (
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.types import a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import (
+    PROTOCOL_VERSION_CURRENT,
+    VERSION_HEADER,
+    TransportProtocol,
+)
+from a2a.utils.errors import (
+    ContentTypeNotSupportedError,
+    ExtendedAgentCardNotConfiguredError,
+    ExtensionSupportRequiredError,
+    InvalidAgentResponseError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+    VersionNotSupportedError,
+)
+from a2a.utils.signing import (
+    create_agent_card_signer,
+    create_signature_verifier,
+)
+from cryptography.hazmat.primitives.asymmetric import ec
+from google.protobuf.json_format import MessageToDict
+from google.protobuf.timestamp_pb2 import Timestamp
+from starlette.applications import Starlette
+
+
+# --- Test Constants ---
+
+TASK_FROM_STREAM = Task(
+    id='task-123-stream',
+    context_id='ctx-456-stream',
+    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+)
+
+TASK_FROM_BLOCKING = Task(
+    id='task-789-blocking',
+    context_id='ctx-101-blocking',
+    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+)
+
+GET_TASK_RESPONSE = Task(
+    id='task-get-456',
+    context_id='ctx-get-789',
+    status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+)
+
+CANCEL_TASK_RESPONSE = Task(
+    id='task-cancel-789',
+    context_id='ctx-cancel-101',
+    status=TaskStatus(state=TaskState.TASK_STATE_CANCELED),
+)
+
+CALLBACK_CONFIG = TaskPushNotificationConfig(
+    task_id='task-callback-123',
+    id='pnc-abc',
+    url='http://callback.example.com',
+    token='',
+)
+
+RESUBSCRIBE_EVENT = TaskStatusUpdateEvent(
+    task_id='task-resub-456',
+    context_id='ctx-resub-789',
+    status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+)
+
+LIST_TASKS_RESPONSE = ListTasksResponse(
+    tasks=[TASK_FROM_BLOCKING, GET_TASK_RESPONSE],
+    next_page_token='page-2',
+    total_size=12,
+    page_size=10,
+)
+
+
+def create_key_provider(verification_key: Any):
+    """Creates a key provider function for testing."""
+
+    def key_provider(kid: str | None, jku: str | None):
+        return verification_key
+
+    return key_provider
+
+
+# --- Test Fixtures ---
+
+
+@pytest.fixture
+def mock_request_handler(agent_card) -> AsyncMock:
+    """Provides a mock RequestHandler for the server-side handlers."""
+    handler = AsyncMock(spec=RequestHandler)
+
+    # Configure on_message_send for non-streaming calls
+    handler._agent_card = agent_card
+    handler.on_message_send.return_value = TASK_FROM_BLOCKING
+
+    # Configure on_message_send_stream for streaming calls
+    async def stream_side_effect(*args, **kwargs):
+        yield TASK_FROM_STREAM
+
+    handler.on_message_send_stream.side_effect = stream_side_effect
+
+    # Configure other methods
+    handler.on_get_task.return_value = GET_TASK_RESPONSE
+    handler.on_cancel_task.return_value = CANCEL_TASK_RESPONSE
+    handler.on_list_tasks.return_value = LIST_TASKS_RESPONSE
+    handler.on_create_task_push_notification_config.return_value = (
+        CALLBACK_CONFIG
+    )
+    handler.on_get_task_push_notification_config.return_value = CALLBACK_CONFIG
+    handler.on_list_task_push_notification_configs.return_value = (
+        ListTaskPushNotificationConfigsResponse(configs=[CALLBACK_CONFIG])
+    )
+    handler.on_delete_task_push_notification_config.return_value = None
+
+    # Use async def to ensure it returns an awaitable
+    async def get_extended_agent_card_mock(*args, **kwargs):
+        return agent_card
+
+    handler.on_get_extended_agent_card.side_effect = (
+        get_extended_agent_card_mock  # type: ignore[union-attr]
+    )
+
+    async def resubscribe_side_effect(*args, **kwargs):
+        yield RESUBSCRIBE_EVENT
+
+    handler.on_subscribe_to_task.side_effect = resubscribe_side_effect
+
+    return handler
+
+
+@pytest.fixture
+def agent_card() -> AgentCard:
+    """Provides a sample AgentCard for tests."""
+    return AgentCard(
+        name='Test Agent',
+        description='An agent for integration testing.',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True, push_notifications=True, extended_agent_card=True
+        ),
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC, url='localhost:50051'
+            ),
+        ],
+    )
+
+
+class TransportSetup(NamedTuple):
+    """Holds the client and handler for a given test."""
+
+    client: Client
+    handler: RequestHandler | AsyncMock
+
+
+# --- HTTP/JSON-RPC/REST Setup ---
+
+
+@pytest.fixture
+def http_base_setup(mock_request_handler: AsyncMock, agent_card: AgentCard):
+    """A base fixture to patch the sse-starlette event loop issue."""
+    from sse_starlette import sse
+
+    sse.AppStatus.should_exit_event = asyncio.Event()
+    yield mock_request_handler, agent_card
+
+
+@pytest.fixture
+def jsonrpc_setup(http_base_setup) -> TransportSetup:
+    """Sets up the JsonRpcTransport and in-memory server."""
+    mock_request_handler, agent_card = http_base_setup
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_request_handler, rpc_url='/'
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(transport=httpx.ASGITransport(app=app))
+    factory = ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.JSONRPC],
+        )
+    )
+    client = factory.create(agent_card)
+    return TransportSetup(client=client, handler=mock_request_handler)
+
+
+@pytest.fixture
+def rest_setup(http_base_setup) -> TransportSetup:
+    """Sets up the RestTransport and in-memory server."""
+    mock_request_handler, agent_card = http_base_setup
+    rest_routes = create_rest_routes(mock_request_handler)
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    app = Starlette(routes=[*rest_routes, *agent_card_routes])
+    httpx_client = httpx.AsyncClient(transport=httpx.ASGITransport(app=app))
+    factory = ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+    )
+    client = factory.create(agent_card)
+    return TransportSetup(client=client, handler=mock_request_handler)
+
+
+@pytest_asyncio.fixture
+async def grpc_setup(
+    grpc_server_and_handler: tuple[str, AsyncMock],
+    agent_card: AgentCard,
+) -> TransportSetup:
+    """Sets up the GrpcTransport and in-process server."""
+    server_address, handler = grpc_server_and_handler
+
+    # Update the gRPC interface dynamically based on the assigned port
+    for interface in agent_card.supported_interfaces:
+        if interface.protocol_binding == TransportProtocol.GRPC:
+            interface.url = server_address
+            break
+    else:
+        raise ValueError('No gRPC interface found in agent card')
+
+    factory = ClientFactory(
+        config=ClientConfig(
+            grpc_channel_factory=grpc.aio.insecure_channel,
+            supported_protocol_bindings=[TransportProtocol.GRPC],
+        )
+    )
+    client = factory.create(agent_card)
+    return TransportSetup(client=client, handler=handler)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param('jsonrpc_setup', id='JSON-RPC'),
+        pytest.param('rest_setup', id='REST'),
+        pytest.param('grpc_setup', id='gRPC'),
+    ]
+)
+def transport_setups(request) -> TransportSetup:
+    """Parametrized fixture that runs tests against all supported transports."""
+    return request.getfixturevalue(request.param)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param('jsonrpc_setup', id='JSON-RPC'),
+        pytest.param('rest_setup', id='REST'),
+        pytest.param('grpc_setup', id='gRPC'),
+        pytest.param('grpc_03_setup', id='gRPC-0.3'),
+    ]
+)
+def error_handling_setups(request) -> TransportSetup:
+    """Parametrized fixture for error tests including compat 0.3 endpoint verification."""
+    return request.getfixturevalue(request.param)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param('jsonrpc_setup', id='JSON-RPC'),
+        pytest.param('rest_setup', id='REST'),
+    ]
+)
+def http_transport_setups(request) -> TransportSetup:
+    """Parametrized fixture that runs tests against HTTP-based transports only."""
+    return request.getfixturevalue(request.param)
+
+
+# --- gRPC Setup ---
+
+
+@pytest_asyncio.fixture
+async def grpc_server_and_handler(
+    mock_request_handler: AsyncMock, agent_card: AgentCard
+) -> AsyncGenerator[tuple[str, AsyncMock], None]:
+    """Creates and manages an in-process gRPC test server."""
+    server = grpc.aio.server()
+    port = server.add_insecure_port('[::]:0')
+    server_address = f'localhost:{port}'
+    servicer = GrpcHandler(request_handler=mock_request_handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+    await server.start()
+    try:
+        yield server_address, mock_request_handler
+    finally:
+        await server.stop(None)
+
+
+@pytest_asyncio.fixture
+async def grpc_03_server_and_handler(
+    mock_request_handler: AsyncMock, agent_card: AgentCard
+) -> AsyncGenerator[tuple[str, AsyncMock], None]:
+    """Creates and manages an in-process v0.3 compat gRPC test server."""
+    server = grpc.aio.server()
+    port = server.add_insecure_port('[::]:0')
+    server_address = f'localhost:{port}'
+    servicer = CompatGrpcHandler(
+        request_handler=mock_request_handler,
+    )
+    a2a_v0_3_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+    await server.start()
+    try:
+        yield server_address, mock_request_handler
+    finally:
+        await server.stop(None)
+
+
+@pytest.fixture
+def grpc_03_setup(
+    grpc_03_server_and_handler, agent_card: AgentCard
+) -> TransportSetup:
+    """Sets up the CompatGrpcTransport and in-process 0.3 server."""
+    server_address, handler = grpc_03_server_and_handler
+    from a2a.client.base_client import BaseClient
+    from a2a.client.client import ClientConfig
+    from a2a.compat.v0_3.grpc_transport import CompatGrpcTransport
+
+    channel = grpc.aio.insecure_channel(server_address)
+    transport = CompatGrpcTransport(channel=channel, agent_card=agent_card)
+
+    client = BaseClient(
+        card=agent_card,
+        config=ClientConfig(),
+        transport=transport,
+        interceptors=[],
+    )
+    return TransportSetup(client=client, handler=handler)
+
+
+# --- The Integration Tests ---
+
+
+@pytest.mark.asyncio
+async def test_client_sends_message_streaming(transport_setups) -> None:
+    """Integration test for all transports streaming."""
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-integration-test',
+        parts=[Part(text='Hello, integration test!')],
+    )
+    params = SendMessageRequest(message=message_to_send)
+
+    stream = client.send_message(request=params)
+    events = [event async for event in stream]
+
+    assert len(events) == 1
+    event = events[0]
+    task = event.task
+    assert task is not None
+    assert task.id == TASK_FROM_STREAM.id
+
+    handler.on_message_send_stream.assert_called_once_with(params, ANY)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_sends_message_blocking(transport_setups) -> None:
+    """Integration test for all transports blocking."""
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    # Disable streaming to force blocking call
+    assert isinstance(client, BaseClient)
+    client._config.streaming = False
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-integration-test-blocking',
+        parts=[Part(text='Hello, blocking test!')],
+    )
+    params = SendMessageRequest(message=message_to_send)
+
+    events = [event async for event in client.send_message(request=params)]
+
+    assert len(events) == 1
+    event = events[0]
+    task = event.task
+    assert task is not None
+    assert task.id == TASK_FROM_BLOCKING.id
+    handler.on_message_send.assert_awaited_once_with(params, ANY)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_get_task(transport_setups) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = GetTaskRequest(id=GET_TASK_RESPONSE.id)
+    result = await client.get_task(request=params)
+
+    assert result.id == GET_TASK_RESPONSE.id
+    handler.on_get_task.assert_awaited_once_with(params, ANY)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_list_tasks(transport_setups) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    t = Timestamp()
+    t.FromJsonString('2024-03-09T16:00:00Z')
+    params = ListTasksRequest(
+        context_id='ctx-1',
+        status=TaskState.TASK_STATE_WORKING,
+        page_size=10,
+        page_token='page-1',
+        history_length=5,
+        status_timestamp_after=t,
+        include_artifacts=True,
+    )
+    result = await client.list_tasks(request=params)
+
+    assert len(result.tasks) == 2
+    assert result.next_page_token == 'page-2'
+    handler.on_list_tasks.assert_awaited_once_with(params, ANY)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_cancel_task(transport_setups) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = CancelTaskRequest(id=CANCEL_TASK_RESPONSE.id)
+    result = await client.cancel_task(request=params)
+
+    assert result.id == CANCEL_TASK_RESPONSE.id
+    handler.on_cancel_task.assert_awaited_once_with(params, ANY)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_create_task_push_notification_config(
+    transport_setups,
+) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = TaskPushNotificationConfig(task_id='task-callback-123')
+    result = await client.create_task_push_notification_config(request=params)
+
+    assert result.id == CALLBACK_CONFIG.id
+    handler.on_create_task_push_notification_config.assert_awaited_once_with(
+        params, ANY
+    )
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_get_task_push_notification_config(
+    transport_setups,
+) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = GetTaskPushNotificationConfigRequest(
+        task_id=CALLBACK_CONFIG.task_id,
+        id=CALLBACK_CONFIG.id,
+    )
+    result = await client.get_task_push_notification_config(request=params)
+
+    assert result.id == CALLBACK_CONFIG.id
+    handler.on_get_task_push_notification_config.assert_awaited_once_with(
+        params, ANY
+    )
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_list_task_push_notification_configs(
+    transport_setups,
+) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = ListTaskPushNotificationConfigsRequest(
+        task_id=CALLBACK_CONFIG.task_id,
+    )
+    result = await client.list_task_push_notification_configs(request=params)
+
+    assert len(result.configs) == 1
+    handler.on_list_task_push_notification_configs.assert_awaited_once_with(
+        params, ANY
+    )
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_delete_task_push_notification_config(
+    transport_setups,
+) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id=CALLBACK_CONFIG.task_id,
+        id=CALLBACK_CONFIG.id,
+    )
+    await client.delete_task_push_notification_config(request=params)
+
+    handler.on_delete_task_push_notification_config.assert_awaited_once_with(
+        params, ANY
+    )
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_subscribe(transport_setups) -> None:
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    params = SubscribeToTaskRequest(id=RESUBSCRIBE_EVENT.task_id)
+    stream = client.subscribe(request=params)
+    first_event = await stream.__anext__()
+
+    assert first_event.status_update.task_id == RESUBSCRIBE_EVENT.task_id
+    handler.on_subscribe_to_task.assert_called_once()
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_get_extended_agent_card(
+    transport_setups, agent_card
+) -> None:
+    client = transport_setups.client
+    result = await client.get_extended_agent_card(GetExtendedAgentCardRequest())
+    # The result could be the original card or a slightly modified one depending on transport
+    assert result.name in [agent_card.name, 'Extended Agent Card']
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_json_transport_base_client_send_message_with_extensions(
+    jsonrpc_setup: TransportSetup, agent_card: AgentCard
+) -> None:
+    """
+    Integration test for BaseClient with JSON-RPC transport to ensure extensions are included in headers.
+    """
+    client_obj = jsonrpc_setup.client
+    assert isinstance(client_obj, BaseClient)
+    transport = client_obj._transport
+    agent_card.capabilities.streaming = False
+
+    # Create a BaseClient instance
+    client = BaseClient(
+        card=agent_card,
+        config=ClientConfig(streaming=False),
+        transport=transport,
+        interceptors=[],
+    )
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-integration-test-extensions',
+        parts=[Part(text='Hello, extensions test!')],
+    )
+    extensions = [
+        'https://example.com/test-ext/v1',
+        'https://example.com/test-ext/v2',
+    ]
+
+    with patch.object(
+        transport, '_send_request', new_callable=AsyncMock
+    ) as mock_send_request:
+        # Mock returns a JSON-RPC response with SendMessageResponse structure
+        mock_send_request.return_value = {
+            'id': '123',
+            'jsonrpc': '2.0',
+            'result': {'task': MessageToDict(TASK_FROM_BLOCKING)},
+        }
+
+        service_params = ServiceParametersFactory.create(
+            [with_a2a_extensions(extensions)]
+        )
+        context = ClientCallContext(service_parameters=service_params)
+
+        # Call send_message on the BaseClient
+        async for _ in client.send_message(
+            request=SendMessageRequest(message=message_to_send), context=context
+        ):
+            pass
+
+        mock_send_request.assert_called_once()
+        call_args, call_kwargs = mock_send_request.call_args
+        called_context = (
+            call_args[1] if len(call_args) > 1 else call_kwargs.get('context')
+        )
+        service_params = getattr(called_context, 'service_parameters', {})
+        assert 'A2A-Extensions' in service_params
+        assert (
+            service_params['A2A-Extensions']
+            == 'https://example.com/test-ext/v1,https://example.com/test-ext/v2'
+        )
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_json_transport_get_signed_base_card(
+    jsonrpc_setup: TransportSetup, agent_card: AgentCard
+) -> None:
+    """Tests fetching and verifying a symmetrically signed AgentCard via JSON-RPC.
+
+    The client transport is initialized without a card, forcing it to fetch
+    the base card from the server. The server signs the card using HS384.
+    The client then verifies the signature.
+    """
+    mock_request_handler = jsonrpc_setup.handler
+    agent_card.capabilities.extended_agent_card = False
+
+    # Setup signing on the server side
+    key = 'testkey12345678901234567890123456789012345678901'
+    signer = create_agent_card_signer(
+        signing_key=key,
+        protected_header={
+            'alg': 'HS384',
+            'kid': 'testkey',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+
+    async def async_signer(card: AgentCard) -> AgentCard:
+        return signer(card)
+
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/', card_modifier=async_signer
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_request_handler, rpc_url='/'
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        headers={VERSION_HEADER: PROTOCOL_VERSION_CURRENT},
+    )
+
+    agent_url = agent_card.supported_interfaces[0].url
+    signature_verifier = create_signature_verifier(
+        create_key_provider(key), ['HS384']
+    )
+
+    resolver = A2ACardResolver(
+        httpx_client=httpx_client,
+        base_url=agent_url,
+    )
+
+    # Verification happens here
+    result = await resolver.get_agent_card(
+        relative_card_path='/',
+        signature_verifier=signature_verifier,
+    )
+
+    # Create transport with the verified card
+    transport = JsonRpcTransport(
+        httpx_client=httpx_client,
+        agent_card=result,
+        url=agent_url,
+    )
+
+    assert result.name == agent_card.name
+    assert len(result.signatures) == 1
+
+    await transport.close()
+
+
+@pytest.mark.asyncio
+async def test_client_get_signed_extended_card(
+    jsonrpc_setup: TransportSetup, agent_card: AgentCard
+) -> None:
+    """Tests fetching and verifying an asymmetrically signed extended AgentCard at the client level.
+
+    The client has a base card and fetches the extended card, which is signed
+    by the server using ES256. The client verifies the signature on the
+    received extended card.
+    """
+    mock_request_handler = jsonrpc_setup.handler
+    agent_card.capabilities.extended_agent_card = True
+    extended_agent_card = AgentCard()
+    extended_agent_card.CopyFrom(agent_card)
+    extended_agent_card.name = 'Extended Agent Card'
+
+    # Setup signing on the server side
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    public_key = private_key.public_key()
+    signer = create_agent_card_signer(
+        signing_key=private_key,
+        protected_header={
+            'alg': 'ES256',
+            'kid': 'testkey',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+
+    async def get_extended_agent_card_mock_2(*args, **kwargs) -> AgentCard:
+        return signer(extended_agent_card)
+
+    mock_request_handler.on_get_extended_agent_card.side_effect = (
+        get_extended_agent_card_mock_2  # type: ignore[union-attr]
+    )
+
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_request_handler, rpc_url='/'
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        headers={VERSION_HEADER: PROTOCOL_VERSION_CURRENT},
+    )
+
+    transport = JsonRpcTransport(
+        httpx_client=httpx_client,
+        agent_card=agent_card,
+        url=agent_card.supported_interfaces[0].url,
+    )
+    client = BaseClient(
+        card=agent_card,
+        config=ClientConfig(streaming=False),
+        transport=transport,
+        interceptors=[],
+    )
+
+    signature_verifier = create_signature_verifier(
+        create_key_provider(public_key), ['HS384', 'ES256']
+    )
+    # Get the card, this will trigger verification in get_extended_agent_card
+    result = await client.get_extended_agent_card(
+        GetExtendedAgentCardRequest(),
+        signature_verifier=signature_verifier,
+    )
+    assert result.name == extended_agent_card.name
+    assert result.signatures is not None
+    assert len(result.signatures) == 1
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_client_get_signed_base_and_extended_cards(
+    jsonrpc_setup: TransportSetup, agent_card: AgentCard
+) -> None:
+    """Tests fetching and verifying both base and extended cards at the client level when no card is initially provided.
+
+    The client starts with no card. It first fetches the base card, which is
+    signed. It then fetches the extended card, which is also signed. Both signatures
+    are verified independently upon retrieval.
+    """
+    mock_request_handler = jsonrpc_setup.handler
+    assert len(agent_card.signatures) == 0
+    agent_card.capabilities.extended_agent_card = True
+    extended_agent_card = AgentCard()
+    extended_agent_card.CopyFrom(agent_card)
+    extended_agent_card.name = 'Extended Agent Card'
+
+    # Setup signing on the server side
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    public_key = private_key.public_key()
+    signer = create_agent_card_signer(
+        signing_key=private_key,
+        protected_header={
+            'alg': 'ES256',
+            'kid': 'testkey',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+    signer(extended_agent_card)
+
+    # Use async def to ensure it returns an awaitable
+    async def get_extended_agent_card_mock_3(*args, **kwargs):
+        return extended_agent_card
+
+    mock_request_handler.on_get_extended_agent_card.side_effect = (
+        get_extended_agent_card_mock_3  # type: ignore[union-attr]
+    )
+
+    async def async_signer(card: AgentCard) -> AgentCard:
+        return signer(card)
+
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/', card_modifier=async_signer
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_request_handler, rpc_url='/'
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        headers={VERSION_HEADER: PROTOCOL_VERSION_CURRENT},
+    )
+
+    agent_url = agent_card.supported_interfaces[0].url
+    signature_verifier = create_signature_verifier(
+        create_key_provider(public_key), ['HS384', 'ES256', 'RS256']
+    )
+
+    resolver = A2ACardResolver(
+        httpx_client=httpx_client,
+        base_url=agent_url,
+    )
+
+    # 1. Fetch base card
+    base_card = await resolver.get_agent_card(
+        relative_card_path='/',
+        signature_verifier=signature_verifier,
+    )
+
+    # 2. Create transport with base card
+    transport = JsonRpcTransport(
+        httpx_client=httpx_client,
+        agent_card=base_card,
+        url=agent_url,
+    )
+    client = BaseClient(
+        card=base_card,
+        config=ClientConfig(streaming=False),
+        transport=transport,
+        interceptors=[],
+    )
+
+    # 3. Fetch extended card via client
+    result = await client.get_extended_agent_card(
+        GetExtendedAgentCardRequest(),
+        signature_verifier=signature_verifier,
+    )
+    assert result.name == extended_agent_card.name
+    assert len(result.signatures) == 1
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'error_cls',
+    [
+        TaskNotFoundError,
+        TaskNotCancelableError,
+        PushNotificationNotSupportedError,
+        UnsupportedOperationError,
+        ContentTypeNotSupportedError,
+        InvalidAgentResponseError,
+        ExtendedAgentCardNotConfiguredError,
+        ExtensionSupportRequiredError,
+        VersionNotSupportedError,
+    ],
+)
+async def test_client_handles_a2a_errors(transport_setups, error_cls) -> None:
+    """Integration test to verify error propagation from handler to client."""
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    # Mock the handler to raise the error
+    handler.on_get_task.side_effect = error_cls('Test error message')
+
+    params = GetTaskRequest(id='some-id')
+
+    # We expect the client to raise the same error_cls.
+    with pytest.raises(error_cls) as exc_info:
+        await client.get_task(request=params)
+
+    assert 'Test error message' in str(exc_info.value)
+
+    # Reset side_effect for other tests
+    handler.on_get_task.side_effect = None
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'error_cls',
+    [
+        TaskNotFoundError,
+        TaskNotCancelableError,
+        PushNotificationNotSupportedError,
+        UnsupportedOperationError,
+        ContentTypeNotSupportedError,
+        InvalidAgentResponseError,
+        ExtendedAgentCardNotConfiguredError,
+        ExtensionSupportRequiredError,
+        VersionNotSupportedError,
+    ],
+)
+@pytest.mark.parametrize(
+    'handler_attr, client_method, request_params',
+    [
+        pytest.param(
+            'on_message_send_stream',
+            'send_message',
+            SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id='msg-integration-test',
+                    parts=[Part(text='Hello, integration test!')],
+                )
+            ),
+            id='stream',
+        ),
+        pytest.param(
+            'on_subscribe_to_task',
+            'subscribe',
+            SubscribeToTaskRequest(id='some-id'),
+            id='subscribe',
+        ),
+    ],
+)
+async def test_client_handles_a2a_errors_streaming(
+    transport_setups, error_cls, handler_attr, client_method, request_params
+) -> None:
+    """Integration test to verify error propagation from streaming handlers to client.
+
+    The handler raises an A2AError before yielding any events. All transports
+    must propagate this as the exact error_cls, not wrapped in an ExceptionGroup
+    or converted to a generic client error.
+    """
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    async def mock_generator(*args, **kwargs):
+        raise error_cls('Test error message')
+        yield
+
+    getattr(handler, handler_attr).side_effect = mock_generator
+
+    with pytest.raises(error_cls) as exc_info:
+        async for _ in getattr(client, client_method)(request=request_params):
+            pass
+
+    assert 'Test error message' in str(exc_info.value)
+
+    getattr(handler, handler_attr).side_effect = None
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'error_cls,handler_attr,client_method,request_params',
+    [
+        pytest.param(
+            UnsupportedOperationError,
+            'on_subscribe_to_task',
+            'subscribe',
+            SubscribeToTaskRequest(id='some-id'),
+            id='subscribe',
+        ),
+    ],
+)
+async def test_server_rejects_stream_on_validation_error(
+    transport_setups, error_cls, handler_attr, client_method, request_params
+) -> None:
+    """Verify that the server returns an error directly and doesn't open a stream on validation error."""
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    async def mock_generator(*args, **kwargs):
+        raise error_cls('Validation failed')
+        yield
+
+    getattr(handler, handler_attr).side_effect = mock_generator
+
+    transport = client._transport
+
+    if isinstance(transport, (RestTransport, JsonRpcTransport)):
+        # Spy on httpx client to check response headers
+        original_send = transport.httpx_client.send
+        response_headers = {}
+
+        async def mock_send(*args, **kwargs):
+            resp = await original_send(*args, **kwargs)
+            response_headers['Content-Type'] = resp.headers.get('Content-Type')
+            return resp
+
+        transport.httpx_client.send = mock_send
+
+        try:
+            with pytest.raises(error_cls):
+                async for _ in getattr(client, client_method)(
+                    request=request_params
+                ):
+                    pass
+        finally:
+            transport.httpx_client.send = original_send
+
+        # Verify that the response content type was NOT text/event-stream
+        assert not response_headers.get('Content-Type', '').startswith(
+            'text/event-stream'
+        )
+    else:
+        # For gRPC, we just verify it raises the error
+        with pytest.raises(error_cls):
+            async for _ in getattr(client, client_method)(
+                request=request_params
+            ):
+                pass
+
+    getattr(handler, handler_attr).side_effect = None
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'request_kwargs, expected_error_code',
+    [
+        pytest.param(
+            {'content': 'not a json'},
+            -32700,  # Parse error
+            id='invalid-json',
+        ),
+        pytest.param(
+            {
+                'json': {
+                    'jsonrpc': '2.0',
+                    'method': 'SendMessage',
+                    # A field of the wrong shape, not merely an unknown
+                    # one: `{'message': 'a string'}` now parses to an empty
+                    # Message and is rejected by the handler's required-field
+                    # validation, which a mock handler does not run.
+                    'params': {'message': {'parts': 'should be a list'}},
+                    'id': 1,
+                }
+            },
+            -32602,  # Invalid params
+            id='wrong-params-type',
+        ),
+    ],
+)
+async def test_jsonrpc_malformed_payload(
+    jsonrpc_setup: TransportSetup,
+    request_kwargs: dict[str, Any],
+    expected_error_code: int,
+) -> None:
+    """Integration test to verify that JSON-RPC malformed payloads don't return 500."""
+    client_obj = jsonrpc_setup.client
+    assert isinstance(client_obj, BaseClient)
+    transport = client_obj._transport
+    assert isinstance(transport, JsonRpcTransport)
+    client = transport.httpx_client
+    url = transport.url
+
+    response = await client.post(url, **request_kwargs)
+    assert response.status_code == 200
+    assert response.json()['error']['code'] == expected_error_code
+
+    await transport.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'method, path, request_kwargs',
+    [
+        pytest.param(
+            'POST',
+            '/message:send',
+            {'content': 'not a json'},
+            id='invalid-json',
+        ),
+        pytest.param(
+            'POST',
+            '/message:send',
+            # Wrong shape rather than an unknown name; see the JSON-RPC case.
+            {'json': {'message': {'parts': 'should be a list'}}},
+            id='wrong-body-type',
+        ),
+        pytest.param(
+            'GET',
+            '/tasks',
+            {'params': {'historyLength': 'not_an_int'}},
+            id='wrong-query-param-type',
+        ),
+    ],
+)
+async def test_rest_malformed_payload(
+    rest_setup: TransportSetup,
+    method: str,
+    path: str,
+    request_kwargs: dict[str, Any],
+) -> None:
+    """Integration test to verify that REST malformed payloads don't return 500."""
+    client_obj = rest_setup.client
+    assert isinstance(client_obj, BaseClient)
+    transport = client_obj._transport
+    assert isinstance(transport, RestTransport)
+    client = transport.httpx_client
+    url = transport.url
+
+    response = await client.request(method, f'{url}{path}', **request_kwargs)
+    assert response.status_code == 400
+
+    await transport.close()
+
+
+@pytest.mark.asyncio
+async def test_validate_version_unsupported(http_transport_setups) -> None:
+    """Integration test for @validate_version decorator."""
+    client = http_transport_setups.client
+
+    service_params = {'A2A-Version': '2.0.0'}
+    context = ClientCallContext(service_parameters=service_params)
+
+    params = GetTaskRequest(id=GET_TASK_RESPONSE.id)
+
+    with pytest.raises(VersionNotSupportedError):
+        await client.get_task(request=params, context=context)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_validate_decorator_push_notifications_disabled(
+    error_handling_setups, agent_card: AgentCard
+) -> None:
+    """Integration test for @validate decorator with push notifications disabled."""
+    client = error_handling_setups.client
+
+    real_handler = LegacyRequestHandler(
+        agent_executor=AsyncMock(),
+        task_store=AsyncMock(),
+        agent_card=agent_card,
+    )
+
+    error_handling_setups.handler.on_create_task_push_notification_config.side_effect = real_handler.on_create_task_push_notification_config
+
+    params = TaskPushNotificationConfig(
+        task_id='123',
+        id='pnc-123',
+        url='http://example.com',
+    )
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await client.create_task_push_notification_config(request=params)
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_validate_streaming_disabled(
+    error_handling_setups, agent_card: AgentCard
+) -> None:
+    """Integration test for @validate decorator when streaming is disabled."""
+    client = error_handling_setups.client
+    transport = client._transport
+
+    agent_card.capabilities.streaming = False
+
+    real_handler = LegacyRequestHandler(
+        agent_executor=AsyncMock(),
+        task_store=AsyncMock(),
+        agent_card=agent_card,
+    )
+
+    error_handling_setups.handler.on_message_send_stream.side_effect = (
+        real_handler.on_message_send_stream
+    )
+    error_handling_setups.handler.on_subscribe_to_task.side_effect = (
+        real_handler.on_subscribe_to_task
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            parts=[Part(text='hi')],
+            message_id='msg-123',
+        )
+    )
+
+    stream = transport.send_message_streaming(request=params)
+
+    with pytest.raises(UnsupportedOperationError):
+        async for _ in stream:
+            pass
+
+    await transport.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'error_cls',
+    [
+        TaskNotFoundError,
+        TaskNotCancelableError,
+        PushNotificationNotSupportedError,
+        UnsupportedOperationError,
+        ContentTypeNotSupportedError,
+        InvalidAgentResponseError,
+        ExtendedAgentCardNotConfiguredError,
+        ExtensionSupportRequiredError,
+        VersionNotSupportedError,
+    ],
+)
+@pytest.mark.parametrize(
+    'handler_attr, client_method, request_params',
+    [
+        pytest.param(
+            'on_message_send_stream',
+            'send_message',
+            SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id='msg-midstream-test',
+                    parts=[Part(text='Hello, mid-stream test!')],
+                )
+            ),
+            id='stream',
+        ),
+        pytest.param(
+            'on_subscribe_to_task',
+            'subscribe',
+            SubscribeToTaskRequest(id='some-id'),
+            id='subscribe',
+        ),
+    ],
+)
+async def test_client_handles_mid_stream_a2a_errors(
+    transport_setups,
+    error_cls,
+    handler_attr,
+    client_method,
+    request_params,
+) -> None:
+    """Integration test for mid-stream errors sent as SSE error events.
+
+    The handler yields one event successfully, then raises an A2AError.
+    The client must receive the first event and then get the error as the
+    exact error_cls exception. This mirrors test_client_handles_a2a_errors_streaming
+    but verifies the error occurs *after* the stream has started producing events.
+    """
+    client = transport_setups.client
+    handler = transport_setups.handler
+
+    async def mock_generator(*args, **kwargs):
+        yield TASK_FROM_STREAM
+        raise error_cls('Mid-stream error')
+
+    getattr(handler, handler_attr).side_effect = mock_generator
+
+    received_events = []
+    with pytest.raises(error_cls) as exc_info:
+        async for event in getattr(client, client_method)(
+            request=request_params
+        ):
+            received_events.append(event)  # noqa: PERF401
+
+    assert 'Mid-stream error' in str(exc_info.value)
+    assert len(received_events) == 1
+
+    getattr(handler, handler_attr).side_effect = None
+
+    await client.close()
diff --git a/tests/integration/test_copying_observability.py b/tests/integration/test_copying_observability.py
new file mode 100644
index 000000000..c0d195c08
--- /dev/null
+++ b/tests/integration/test_copying_observability.py
@@ -0,0 +1,190 @@
+from typing import NamedTuple
+
+import httpx
+import pytest
+
+from a2a.client.client import Client, ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.tasks import TaskUpdater
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Artifact,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    TaskState,
+)
+from a2a.utils import TransportProtocol
+from starlette.applications import Starlette
+
+
+class MockMutatingAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        assert context.task_id is not None
+        assert context.context_id is not None
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,
+            context.context_id,
+        )
+
+        user_input = context.get_user_input()
+
+        if user_input == 'Init task':
+            # Explicitly save status change to ensure task exists with some state
+            task = new_task_from_user_message(context.message)
+            task.id = context.task_id
+            task.context_id = context.context_id
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+
+            await task_updater.update_status(
+                TaskState.TASK_STATE_WORKING,
+                message=task_updater.new_agent_message(
+                    [Part(text='task working')]
+                ),
+            )
+        else:
+            # Mutate the task WITHOUT saving it properly
+            assert context.current_task is not None
+            context.current_task.artifacts.append(
+                Artifact(
+                    name='leaked-artifact',
+                    parts=[Part(text='leaked artifact')],
+                )
+            )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        raise NotImplementedError('Cancellation is not supported')
+
+
+@pytest.fixture
+def agent_card() -> AgentCard:
+    return AgentCard(
+        name='Mutating Agent',
+        description='Real in-memory integration testing.',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True, push_notifications=False
+        ),
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://testserver',
+            ),
+        ],
+    )
+
+
+class ClientSetup(NamedTuple):
+    client: Client
+    task_store: InMemoryTaskStore
+    use_copying: bool
+
+
+def setup_client(agent_card: AgentCard, use_copying: bool) -> ClientSetup:
+    task_store = InMemoryTaskStore(use_copying=use_copying)
+    handler = DefaultRequestHandler(
+        agent_executor=MockMutatingAgentExecutor(),
+        task_store=task_store,
+        agent_card=agent_card,
+        queue_manager=InMemoryQueueManager(),
+        extended_agent_card=agent_card,
+    )
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler,
+        rpc_url='/',
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url='http://testserver'
+    )
+    factory = ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.JSONRPC],
+        )
+    )
+    client = factory.create(agent_card)
+    return ClientSetup(
+        client=client,
+        task_store=task_store,
+        use_copying=use_copying,
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_copying', [True, False])
+async def test_mutation_observability(agent_card: AgentCard, use_copying: bool):
+    """Tests that task mutations are observable when copying is disabled.
+
+    When copying is disabled, the agent mutates the task in-place and the
+    changes are observable by the client. When copying is enabled, the agent
+    mutates a copy of the task and the changes are not observable by the client.
+
+    It is ok to remove the `use_copying` parameter from the system in the future
+    to make InMemoryTaskStore consistent with other task stores.
+    """
+    client_setup = setup_client(agent_card, use_copying)
+    client = client_setup.client
+
+    # 1. First message to create the task
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-mut-init',
+        parts=[Part(text='Init task')],
+    )
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send)
+        )
+    ]
+
+    event = events[-1]
+    assert event.HasField('status_update')
+    task_id = event.status_update.task_id
+
+    # 2. Second message to mutate it
+    message_to_send_2 = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-mut-do',
+        task_id=task_id,
+        parts=[Part(text='Update task without saving it')],
+    )
+    _ = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send_2)
+        )
+    ]
+
+    # 3. Get task via client
+    retrieved_task = await client.get_task(request=GetTaskRequest(id=task_id))
+
+    # 4. Assert behavior based on `use_copying`
+    if use_copying:
+        # The un-saved artifact IS NOT leaked to the client
+        assert len(retrieved_task.artifacts) == 0
+    else:
+        # The un-saved artifact IS leaked to the client
+        assert len(retrieved_task.artifacts) == 1
+        assert retrieved_task.artifacts[0].name == 'leaked-artifact'
diff --git a/tests/integration/test_end_to_end.py b/tests/integration/test_end_to_end.py
new file mode 100644
index 000000000..d4276183d
--- /dev/null
+++ b/tests/integration/test_end_to_end.py
@@ -0,0 +1,895 @@
+import json
+
+from collections.abc import AsyncGenerator
+from typing import NamedTuple
+
+import grpc
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.client.base_client import BaseClient
+from a2a.client.client import ClientCallContext, ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.client.service_parameters import (
+    ServiceParametersFactory,
+    with_a2a_extensions,
+)
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler, GrpcHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks import TaskUpdater
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentExtension,
+    AgentInterface,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    TaskState,
+    a2a_pb2_grpc,
+)
+from a2a.utils import TransportProtocol
+from a2a.utils.errors import InvalidParamsError
+from starlette.applications import Starlette
+
+
+SUPPORTED_EXTENSION_URIS = [
+    'https://example.com/ext/v1',
+    'https://example.com/ext/v2',
+]
+
+
+def assert_message_matches(message, expected_role, expected_text):
+    assert message.role == expected_role
+    assert message.parts[0].text == expected_text
+
+
+def assert_history_matches(history, expected_history):
+    assert len(history) == len(expected_history)
+    for msg, (expected_role, expected_text) in zip(
+        history, expected_history, strict=True
+    ):
+        assert_message_matches(msg, expected_role, expected_text)
+
+
+def assert_artifacts_match(artifacts, expected_artifacts):
+    assert len(artifacts) == len(expected_artifacts)
+    for artifact, (expected_name, expected_text) in zip(
+        artifacts, expected_artifacts, strict=True
+    ):
+        assert artifact.name == expected_name
+        assert artifact.parts[0].text == expected_text
+
+
+def assert_events_match(events, expected_events):
+    assert len(events) == len(expected_events)
+    for event, (expected_type, expected_val) in zip(
+        events, expected_events, strict=True
+    ):
+        assert event.HasField(expected_type)
+        if expected_type == 'task':
+            assert event.task.status.state == expected_val
+        elif expected_type == 'status_update':
+            assert event.status_update.status.state == expected_val
+        elif expected_type == 'artifact_update':
+            if expected_val is not None:
+                assert_artifacts_match(
+                    [event.artifact_update.artifact],
+                    expected_val,
+                )
+        else:
+            raise ValueError(f'Unexpected event type: {expected_type}')
+
+
+class MockAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        user_input = context.get_user_input()
+
+        # Extensions echo: report the requested extensions back to the client
+        # via the Message.extensions field.
+        if user_input.startswith('Extensions:'):
+            await event_queue.enqueue_event(
+                Message(
+                    role=Role.ROLE_AGENT,
+                    message_id='ext-reply-1',
+                    parts=[Part(text='extensions echoed')],
+                    extensions=sorted(context.requested_extensions),
+                )
+            )
+            return
+
+        # Direct message response (no task created).
+        if user_input.startswith('Message:'):
+            await event_queue.enqueue_event(
+                Message(
+                    role=Role.ROLE_AGENT,
+                    message_id='direct-reply-1',
+                    parts=[Part(text=f'Direct reply to: {user_input}')],
+                )
+            )
+            return
+
+        # Task-based response.
+        task = context.current_task
+        if not task:
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+
+        task_updater = TaskUpdater(
+            event_queue,
+            task.id,
+            task.context_id,
+        )
+
+        await task_updater.update_status(
+            TaskState.TASK_STATE_WORKING,
+            message=task_updater.new_agent_message([Part(text='task working')]),
+        )
+
+        if user_input == 'Need input':
+            await task_updater.update_status(
+                TaskState.TASK_STATE_INPUT_REQUIRED,
+                message=task_updater.new_agent_message(
+                    [Part(text='Please provide input')]
+                ),
+            )
+        else:
+            await task_updater.add_artifact(
+                parts=[Part(text='artifact content')], name='test-artifact'
+            )
+            await task_updater.update_status(
+                TaskState.TASK_STATE_COMPLETED,
+                message=task_updater.new_agent_message([Part(text='done')]),
+            )
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        assert context.task_id is not None
+        assert context.context_id is not None
+        task_updater = TaskUpdater(
+            event_queue, context.task_id, context.context_id
+        )
+        await task_updater.cancel(
+            message=task_updater.new_agent_message(
+                [Part(text=json.dumps(context.metadata, sort_keys=True))]
+            )
+        )
+
+
+@pytest.fixture
+def agent_card() -> AgentCard:
+    return AgentCard(
+        name='Integration Agent',
+        description='Real in-memory integration testing.',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=False,
+            extensions=[
+                AgentExtension(
+                    uri=uri,
+                    description=f'Test extension {uri}',
+                )
+                for uri in SUPPORTED_EXTENSION_URIS
+            ],
+        ),
+        skills=[],
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='localhost:50051',
+            ),
+        ],
+    )
+
+
+class ClientSetup(NamedTuple):
+    """Holds the client and task_store for a given test."""
+
+    client: BaseClient
+    task_store: InMemoryTaskStore
+
+
+@pytest.fixture
+def base_e2e_setup(agent_card):
+    task_store = InMemoryTaskStore()
+    handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        agent_card=agent_card,
+        queue_manager=InMemoryQueueManager(),
+    )
+    return task_store, handler
+
+
+@pytest.fixture
+def rest_setup(agent_card, base_e2e_setup) -> ClientSetup:
+    task_store, handler = base_e2e_setup
+    rest_routes = create_rest_routes(request_handler=handler)
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    app = Starlette(routes=[*rest_routes, *agent_card_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url='http://testserver'
+    )
+    factory = ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+    )
+    client = factory.create(agent_card)
+    return ClientSetup(
+        client=client,
+        task_store=task_store,
+    )
+
+
+@pytest.fixture
+def jsonrpc_setup(agent_card, base_e2e_setup) -> ClientSetup:
+    task_store, handler = base_e2e_setup
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler,
+        rpc_url='/',
+    )
+    app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+    httpx_client = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url='http://testserver'
+    )
+    factory = ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx_client,
+            supported_protocol_bindings=[TransportProtocol.JSONRPC],
+        )
+    )
+    client = factory.create(agent_card)
+    return ClientSetup(
+        client=client,
+        task_store=task_store,
+    )
+
+
+@pytest_asyncio.fixture
+async def grpc_setup(
+    agent_card: AgentCard, base_e2e_setup
+) -> AsyncGenerator[ClientSetup, None]:
+    task_store, handler = base_e2e_setup
+    server = grpc.aio.server()
+    port = server.add_insecure_port('[::]:0')
+    server_address = f'localhost:{port}'
+
+    grpc_agent_card = AgentCard()
+    grpc_agent_card.CopyFrom(agent_card)
+
+    # Update the gRPC interface dynamically based on the assigned port
+    for interface in grpc_agent_card.supported_interfaces:
+        if interface.protocol_binding == TransportProtocol.GRPC:
+            interface.url = server_address
+            break
+    else:
+        raise ValueError('No gRPC interface found in agent card')
+    handler._agent_card = grpc_agent_card
+    servicer = GrpcHandler(handler)
+    a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+    await server.start()
+
+    factory = ClientFactory(
+        config=ClientConfig(
+            grpc_channel_factory=grpc.aio.insecure_channel,
+            supported_protocol_bindings=[TransportProtocol.GRPC],
+        )
+    )
+    client = factory.create(grpc_agent_card)
+    yield ClientSetup(
+        client=client,
+        task_store=task_store,
+    )
+
+    await client.close()
+    await server.stop(0)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param('rest_setup', id='REST'),
+        pytest.param('jsonrpc_setup', id='JSON-RPC'),
+        pytest.param('grpc_setup', id='gRPC'),
+    ]
+)
+def transport_setups(request) -> ClientSetup:
+    """Parametrized fixture that runs tests against all supported transports."""
+    return request.getfixturevalue(request.param)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param('jsonrpc_setup', id='JSON-RPC'),
+        pytest.param('grpc_setup', id='gRPC'),
+    ]
+)
+def rpc_transport_setups(request) -> ClientSetup:
+    """Parametrized fixture for RPC transports only (excludes REST).
+
+    REST encodes some required fields in URL paths, so empty-field validation
+    tests hit routing errors before reaching the handler. JSON-RPC and gRPC
+    send the full request message, allowing server-side validation to work.
+    """
+    return request.getfixturevalue(request.param)
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_send_message_blocking(transport_setups):
+    client = transport_setups.client
+    client._config.streaming = False
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-blocking',
+        parts=[Part(text='Run dummy agent!')],
+    )
+    configuration = SendMessageConfiguration()
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(
+                message=message_to_send, configuration=configuration
+            )
+        )
+    ]
+    assert len(events) == 1
+    response = events[0]
+    assert response.task.id
+    assert response.task.status.state == TaskState.TASK_STATE_COMPLETED
+    assert_artifacts_match(
+        response.task.artifacts,
+        [('test-artifact', 'artifact content')],
+    )
+    assert_history_matches(
+        response.task.history,
+        [
+            (Role.ROLE_USER, 'Run dummy agent!'),
+            (Role.ROLE_AGENT, 'task working'),
+        ],
+    )
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_send_message_non_blocking(transport_setups):
+    client = transport_setups.client
+    client._config.streaming = False
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-non-blocking',
+        parts=[Part(text='Run dummy agent!')],
+    )
+    configuration = SendMessageConfiguration(return_immediately=True)
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(
+                message=message_to_send, configuration=configuration
+            )
+        )
+    ]
+    assert len(events) == 1
+    response = events[0]
+    assert response.task.id
+    assert response.task.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert_history_matches(
+        response.task.history,
+        [
+            (Role.ROLE_USER, 'Run dummy agent!'),
+        ],
+    )
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_send_message_streaming(transport_setups):
+    client = transport_setups.client
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-streaming',
+        parts=[Part(text='Run dummy agent!')],
+    )
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send)
+        )
+    ]
+
+    assert_events_match(
+        events,
+        [
+            ('task', TaskState.TASK_STATE_SUBMITTED),
+            ('status_update', TaskState.TASK_STATE_WORKING),
+            ('artifact_update', [('test-artifact', 'artifact content')]),
+            ('status_update', TaskState.TASK_STATE_COMPLETED),
+        ],
+    )
+
+    task_id = events[0].task.id
+    task = await client.get_task(request=GetTaskRequest(id=task_id))
+    assert_history_matches(
+        task.history,
+        [
+            (Role.ROLE_USER, 'Run dummy agent!'),
+            (Role.ROLE_AGENT, 'task working'),
+        ],
+    )
+    assert task.status.state == TaskState.TASK_STATE_COMPLETED
+    assert_message_matches(task.status.message, Role.ROLE_AGENT, 'done')
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_get_task(transport_setups):
+    client = transport_setups.client
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-get',
+        parts=[Part(text='Test Get Task')],
+    )
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send)
+        )
+    ]
+    response = events[0]
+    task_id = response.task.id
+
+    get_request = GetTaskRequest(id=task_id)
+    retrieved_task = await client.get_task(request=get_request)
+
+    assert retrieved_task.id == task_id
+    assert retrieved_task.status.state in {
+        TaskState.TASK_STATE_SUBMITTED,
+        TaskState.TASK_STATE_WORKING,
+        TaskState.TASK_STATE_COMPLETED,
+    }
+    assert_history_matches(
+        retrieved_task.history,
+        [
+            (Role.ROLE_USER, 'Test Get Task'),
+            (Role.ROLE_AGENT, 'task working'),
+        ],
+    )
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_list_tasks(transport_setups):
+    client = transport_setups.client
+
+    total_items = 6
+    page_size = 2
+
+    expected_task_ids = []
+    for i in range(total_items):
+        # One event is enough to get the task ID
+        response = await anext(
+            client.send_message(
+                request=SendMessageRequest(
+                    message=Message(
+                        role=Role.ROLE_USER,
+                        message_id=f'msg-e2e-list-{i}',
+                        parts=[Part(text=f'Test List Tasks {i}')],
+                    )
+                )
+            )
+        )
+        expected_task_ids.append(response.task.id)
+
+    list_request = ListTasksRequest(page_size=page_size)
+
+    actual_task_ids = []
+    token = None
+
+    while token != '':
+        if token:
+            list_request.page_token = token
+
+        list_response = await client.list_tasks(request=list_request)
+        assert 0 < len(list_response.tasks) <= page_size
+        assert list_response.total_size == total_items
+        assert list_response.page_size == page_size
+
+        actual_task_ids.extend([task.id for task in list_response.tasks])
+
+        for task in list_response.tasks:
+            assert len(task.history) >= 1
+            assert task.history[0].role == Role.ROLE_USER
+            assert task.history[0].parts[0].text.startswith('Test List Tasks ')
+
+        token = list_response.next_page_token
+
+    assert len(actual_task_ids) == total_items
+    assert sorted(actual_task_ids) == sorted(expected_task_ids)
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_input_required(transport_setups):
+    client = transport_setups.client
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-input-req-1',
+        parts=[Part(text='Need input')],
+    )
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send)
+        )
+    ]
+
+    assert_events_match(
+        events,
+        [
+            ('task', TaskState.TASK_STATE_SUBMITTED),
+            ('status_update', TaskState.TASK_STATE_WORKING),
+            ('status_update', TaskState.TASK_STATE_INPUT_REQUIRED),
+        ],
+    )
+
+    task_id = events[0].task.id
+    task = await client.get_task(request=GetTaskRequest(id=task_id))
+
+    assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert_history_matches(
+        task.history,
+        [
+            (Role.ROLE_USER, 'Need input'),
+            (Role.ROLE_AGENT, 'task working'),
+        ],
+    )
+    assert_message_matches(
+        task.status.message, Role.ROLE_AGENT, 'Please provide input'
+    )
+
+    # Follow-up message
+    follow_up_message = Message(
+        task_id=task.id,
+        role=Role.ROLE_USER,
+        message_id='msg-e2e-input-req-2',
+        parts=[Part(text='Here is the input')],
+    )
+
+    follow_up_events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=follow_up_message)
+        )
+    ]
+
+    assert_events_match(
+        follow_up_events,
+        [
+            ('status_update', TaskState.TASK_STATE_WORKING),
+            ('artifact_update', [('test-artifact', 'artifact content')]),
+            ('status_update', TaskState.TASK_STATE_COMPLETED),
+        ],
+    )
+
+    task = await client.get_task(request=GetTaskRequest(id=task.id))
+
+    assert task.status.state == TaskState.TASK_STATE_COMPLETED
+    assert_artifacts_match(
+        task.artifacts,
+        [('test-artifact', 'artifact content')],
+    )
+
+    assert_history_matches(
+        task.history,
+        [
+            (Role.ROLE_USER, 'Need input'),
+            (Role.ROLE_AGENT, 'task working'),
+            (Role.ROLE_AGENT, 'Please provide input'),
+            (Role.ROLE_USER, 'Here is the input'),
+            (Role.ROLE_AGENT, 'task working'),
+        ],
+    )
+    assert_message_matches(task.status.message, Role.ROLE_AGENT, 'done')
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'empty_request, expected_fields',
+    [
+        (
+            SendMessageRequest(),
+            {'message'},
+        ),
+        (
+            SendMessageRequest(message=Message()),
+            {'message.message_id', 'message.role', 'message.parts'},
+        ),
+        (
+            SendMessageRequest(
+                message=Message(message_id='m1', role=Role.ROLE_USER)
+            ),
+            {'message.parts'},
+        ),
+    ],
+)
+async def test_end_to_end_send_message_validation_errors(
+    transport_setups,
+    empty_request: SendMessageRequest,
+    expected_fields: set[str],
+) -> None:
+    client = transport_setups.client
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        async for _ in client.send_message(request=empty_request):
+            pass
+
+    errors = exc_info.value.data.get('errors', [])
+    assert {e['field'] for e in errors} == expected_fields
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'method, invalid_request, expected_fields',
+    [
+        (
+            'get_task',
+            GetTaskRequest(),
+            {'id'},
+        ),
+        (
+            'cancel_task',
+            CancelTaskRequest(),
+            {'id'},
+        ),
+        (
+            'get_task_push_notification_config',
+            GetTaskPushNotificationConfigRequest(),
+            {'task_id', 'id'},
+        ),
+        (
+            'list_task_push_notification_configs',
+            ListTaskPushNotificationConfigsRequest(),
+            {'task_id'},
+        ),
+        (
+            'delete_task_push_notification_config',
+            DeleteTaskPushNotificationConfigRequest(),
+            {'task_id', 'id'},
+        ),
+    ],
+)
+async def test_end_to_end_unary_validation_errors(
+    rpc_transport_setups,
+    method: str,
+    invalid_request,
+    expected_fields: set[str],
+) -> None:
+    client = rpc_transport_setups.client
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await getattr(client, method)(request=invalid_request)
+
+    errors = exc_info.value.data.get('errors', [])
+    assert {e['field'] for e in errors} == expected_fields
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_subscribe_validation_error(
+    rpc_transport_setups,
+) -> None:
+    client = rpc_transport_setups.client
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        async for _ in client.subscribe(request=SubscribeToTaskRequest()):
+            pass
+
+    errors = exc_info.value.data.get('errors', [])
+    assert {e['field'] for e in errors} == {'id'}
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'streaming',
+    [
+        pytest.param(False, id='blocking'),
+        pytest.param(True, id='streaming'),
+    ],
+)
+async def test_end_to_end_direct_message(transport_setups, streaming):
+    """Test that an executor can return a direct Message without creating a Task."""
+    client = transport_setups.client
+    client._config.streaming = streaming
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-direct',
+        parts=[Part(text='Message: Hello agent')],
+    )
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send)
+        )
+    ]
+
+    assert len(events) == 1
+    response = events[0]
+    assert response.HasField('message')
+    assert not response.HasField('task')
+    assert_message_matches(
+        response.message,
+        Role.ROLE_AGENT,
+        'Direct reply to: Message: Hello agent',
+    )
+
+
+@pytest.mark.asyncio
+async def test_end_to_end_direct_message_return_immediately(transport_setups):
+    """Test that return_immediately still returns the Message for direct replies.
+
+    When the executor responds with a direct Message, the response is
+    inherently immediate -- there is no async task to defer to. The client
+    should receive the Message regardless of the return_immediately flag.
+    """
+    client = transport_setups.client
+    client._config.streaming = False
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-direct-return-immediately',
+        parts=[Part(text='Message: Quick question')],
+    )
+    configuration = SendMessageConfiguration(return_immediately=True)
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(
+                message=message_to_send, configuration=configuration
+            )
+        )
+    ]
+
+    assert len(events) == 1
+    response = events[0]
+    assert response.HasField('message')
+    assert not response.HasField('task')
+    assert_message_matches(
+        response.message,
+        Role.ROLE_AGENT,
+        'Direct reply to: Message: Quick question',
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'streaming',
+    [
+        pytest.param(False, id='blocking'),
+        pytest.param(True, id='streaming'),
+    ],
+)
+async def test_end_to_end_extensions_propagation(transport_setups, streaming):
+    """Test that extensions sent by the client reach the agent executor."""
+    client = transport_setups.client
+    client._config.streaming = streaming
+
+    service_params = ServiceParametersFactory.create(
+        [with_a2a_extensions(SUPPORTED_EXTENSION_URIS)]
+    )
+    context = ClientCallContext(service_parameters=service_params)
+
+    message_to_send = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-ext-propagation',
+        parts=[Part(text='Extensions: echo')],
+    )
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(message=message_to_send),
+            context=context,
+        )
+    ]
+
+    assert len(events) == 1
+    response = events[0]
+    assert response.HasField('message')
+    assert_message_matches(
+        response.message, Role.ROLE_AGENT, 'extensions echoed'
+    )
+    assert set(response.message.extensions) == set(SUPPORTED_EXTENSION_URIS)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'cancel_metadata',
+    [
+        pytest.param(
+            {'reason': 'user_aborted', 'nested': {'retryable': False}},
+            id='with_metadata',
+        ),
+        pytest.param({}, id='without_metadata'),
+    ],
+)
+async def test_end_to_end_cancel_task_metadata_propagation(
+    transport_setups: ClientSetup,
+    cancel_metadata: dict[str, object],
+) -> None:
+    """Test CancelTaskRequest.metadata reaches AgentExecutor.cancel on all bindings."""
+    client = transport_setups.client
+    client._config.streaming = False
+
+    events = [
+        event
+        async for event in client.send_message(
+            request=SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id='msg-cancel-metadata',
+                    parts=[Part(text='Need input')],
+                )
+            )
+        )
+    ]
+    assert len(events) == 1
+    parked_task = events[0].task
+    assert parked_task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    cancel_req = (
+        CancelTaskRequest(id=parked_task.id, metadata=cancel_metadata)
+        if cancel_metadata
+        else CancelTaskRequest(id=parked_task.id)
+    )
+    cancelled_task = await client.cancel_task(request=cancel_req)
+
+    assert cancelled_task.id == parked_task.id
+    assert cancelled_task.status.state == TaskState.TASK_STATE_CANCELED
+    assert json.loads(cancelled_task.status.message.parts[0].text) == (
+        cancel_metadata
+    )
diff --git a/tests/integration/test_multiserver.py b/tests/integration/test_multiserver.py
new file mode 100644
index 000000000..d376e4cc6
--- /dev/null
+++ b/tests/integration/test_multiserver.py
@@ -0,0 +1,595 @@
+import asyncio
+import contextlib
+import os
+
+from collections.abc import AsyncGenerator
+
+import pytest
+import pytest_asyncio
+
+from _pytest.mark.structures import ParameterSet
+
+
+pytest.importorskip('sqlalchemy', reason='Database tests require SQLAlchemy')
+
+from a2a.auth.user import User
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.cluster.database_event_stream import DatabaseTaskEventStream
+from a2a.server.cluster.database_task_store import VersionedDatabaseTaskStore
+from a2a.server.context import ServerCallContext
+from a2a.server.models import Base
+from a2a.server.request_handlers.default_request_handler_v2 import (
+    DefaultRequestHandlerV2,
+)
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    CancelTaskRequest,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    TaskState,
+)
+from a2a.utils.errors import (
+    A2AError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from sqlalchemy.ext.asyncio import create_async_engine
+
+
+# --- DSN parametrization -----------------------------------------------------
+
+POSTGRES_TEST_DSN = os.environ.get('POSTGRES_TEST_DSN')
+MYSQL_TEST_DSN = os.environ.get('MYSQL_TEST_DSN')
+
+
+DB_CONFIGS: list[ParameterSet | tuple[str | None, str]] = []
+if POSTGRES_TEST_DSN:
+    DB_CONFIGS.append(
+        pytest.param((POSTGRES_TEST_DSN, 'postgresql'), id='postgresql')
+    )
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'postgresql'),
+            marks=pytest.mark.skip(reason='POSTGRES_TEST_DSN not set'),
+            id='postgresql_skipped',
+        )
+    )
+if MYSQL_TEST_DSN:
+    DB_CONFIGS.append(pytest.param((MYSQL_TEST_DSN, 'mysql'), id='mysql'))
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'mysql'),
+            marks=pytest.mark.skip(reason='MYSQL_TEST_DSN not set'),
+            id='mysql_skipped',
+        )
+    )
+
+
+# --- Helpers and test agents definitions ------------------------------------
+
+
+class SampleUser(User):
+    """Minimal authenticated user for tests."""
+
+    def __init__(self, user_name: str = 'test_user') -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def make_context(user: str = 'test_user') -> ServerCallContext:
+    return ServerCallContext(user=SampleUser(user))
+
+
+def streaming_agent_card() -> AgentCard:
+    return AgentCard(capabilities=AgentCapabilities(streaming=True))
+
+
+def build_send_request(
+    text: str,
+    task_id: str = '',
+    context_id: str = '',
+    message_id: str = 'm',
+) -> SendMessageRequest:
+    msg = Message(
+        role=Role.ROLE_USER, message_id=message_id, parts=[Part(text=text)]
+    )
+    if task_id:
+        msg.task_id = task_id
+    if context_id:
+        msg.context_id = context_id
+    return SendMessageRequest(message=msg)
+
+
+async def wait_for_state(
+    store: VersionedDatabaseTaskStore,
+    task_id: str,
+    state: TaskState,
+    context: ServerCallContext,
+    *,
+    tries: int = 200,
+    delay: float = 0.02,
+) -> None:
+    for _ in range(tries):
+        stored = await store.get(task_id, context)
+        if stored is not None and stored.task.status.state == state:
+            return
+        await asyncio.sleep(delay)
+    raise AssertionError(f'Task {task_id} did not reach {state} in time')
+
+
+class CompletingAgent(AgentExecutor):
+    """Creates the task if needed, goes WORKING, then completes."""
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class ControlledAgent(AgentExecutor):
+    """Goes WORKING, then completes only when released."""
+
+    def __init__(self) -> None:
+        self.working = asyncio.Event()
+        self.release = asyncio.Event()
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        self.working.set()
+        await self.release.wait()
+        await updater.add_artifact([Part(text='result')])
+        await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class LongRunningAgent(AgentExecutor):
+    """Goes WORKING then saves periodically until aborted by a CAS conflict."""
+
+    def __init__(self) -> None:
+        self.working = asyncio.Event()
+        self.aborted = asyncio.Event()
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        self.working.set()
+        try:
+            for _ in range(200):
+                await asyncio.sleep(0.05)
+                await updater.update_status(
+                    TaskState.TASK_STATE_WORKING,
+                    message=updater.new_agent_message([Part(text='tick')]),
+                )
+        except asyncio.CancelledError:
+            self.aborted.set()
+            raise
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class InputRequiredThenCompleteAgent(AgentExecutor):
+    """Asks for input until two user turns exist, then completes.
+
+    Turn is derived purely from durable task history, so it behaves correctly
+    regardless of which replica runs each turn.
+    """
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        task = context.current_task
+        if task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        user_msgs = 0
+        if task is not None:
+            user_msgs = sum(1 for m in task.history if m.role == Role.ROLE_USER)
+
+        if task is None or user_msgs <= 1:
+            await updater.requires_input(
+                message=updater.new_agent_message([Part(text='need input')])
+            )
+        else:
+            await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+# --- simulate multi-replica deployment with 2 DefaultRequestHandlerV2 instances over shared DB
+
+
+class Cluster:
+    """A pair of replicas over one shared database."""
+
+    def __init__(
+        self,
+        dsn: str,
+        agent_a: AgentExecutor,
+        agent_b: AgentExecutor,
+    ) -> None:
+        self._dsn = dsn
+        self._engines = []
+        self.replica_a = self._make_replica(agent_a)
+        self.replica_b = self._make_replica(agent_b)
+
+    def _make_replica(self, agent: AgentExecutor) -> DefaultRequestHandlerV2:
+        engine = create_async_engine(self._dsn)
+        self._engines.append(engine)
+        store = VersionedDatabaseTaskStore(engine=engine, create_table=False)
+        stream = DatabaseTaskEventStream(
+            engine=engine, create_table=False, poll_interval_s=0.05
+        )
+        return DefaultRequestHandlerV2(
+            agent_executor=agent,
+            task_store=store,
+            agent_card=streaming_agent_card(),
+            event_stream=stream,
+        )
+
+    async def aclose(self) -> None:
+        with contextlib.suppress(Exception):
+            await self.replica_a.aclose()
+        with contextlib.suppress(Exception):
+            await self.replica_b.aclose()
+        for engine in self._engines:
+            await engine.dispose()
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def dsn(request) -> AsyncGenerator[str, None]:
+    param, dialect = request.param
+    if param is None:
+        pytest.skip(f'DSN for {dialect} not set.')
+    url = param
+
+    engine = create_async_engine(url)
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        yield url
+    finally:
+        with contextlib.suppress(Exception):
+            async with engine.begin() as conn:
+                await conn.run_sync(Base.metadata.drop_all)
+        await engine.dispose()
+
+
+# --- Scenarios --------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_concurrent_followups_no_lost_update(dsn: str) -> None:
+    """Racing follow-up sends from both replicas never lose an accepted write.
+
+    A replica that keeps losing the compare-and-swap rejects its follow-up
+    with an A2AError instead of retrying forever; only a follow-up that
+    returned successfully must be persisted.
+    """
+    cluster = Cluster(
+        dsn,
+        InputRequiredThenCompleteAgent(),
+        InputRequiredThenCompleteAgent(),
+    )
+    ctx = make_context()
+    try:
+        r1 = await cluster.replica_a.on_message_send(
+            build_send_request('q1', message_id='m1'), ctx
+        )
+        assert r1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        task_id = r1.id
+        context_id = r1.context_id
+
+        # Two concurrent follow-ups for the same task, one per replica.
+        results = await asyncio.gather(
+            cluster.replica_a.on_message_send(
+                build_send_request(
+                    'a', task_id=task_id, context_id=context_id, message_id='ma'
+                ),
+                ctx,
+            ),
+            cluster.replica_b.on_message_send(
+                build_send_request(
+                    'b', task_id=task_id, context_id=context_id, message_id='mb'
+                ),
+                ctx,
+            ),
+            return_exceptions=True,
+        )
+        # Conflicts are handled internally; only an A2AError may surface.
+        for r in results:
+            if isinstance(r, BaseException):
+                assert isinstance(r, A2AError), r
+
+        # Durable task intact: q1 and every accepted follow-up survived.
+        final = await cluster.replica_a.task_store.get(task_id, ctx)
+        assert final is not None
+        assert not final.version.is_missing
+        user_turns = {
+            m.message_id for m in final.task.history if m.role == Role.ROLE_USER
+        }
+        accepted = {
+            message_id
+            for message_id, r in zip(('ma', 'mb'), results, strict=True)
+            if not isinstance(r, BaseException)
+        }
+        assert accepted, results
+        assert {'m1', *accepted} <= user_turns, [
+            m.message_id for m in final.task.history
+        ]
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_multiturn_input_required_across_replicas(dsn: str) -> None:
+    """turn 1 -> A, turn 2 -> B, turn 3 -> A; no stale-snapshot clobber."""
+    cluster = Cluster(
+        dsn,
+        InputRequiredThenCompleteAgent(),
+        InputRequiredThenCompleteAgent(),
+    )
+    ctx = make_context()
+    try:
+        r1 = await cluster.replica_a.on_message_send(
+            build_send_request('q1', message_id='m1'), ctx
+        )
+        assert r1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        task_id = r1.id
+        context_id = r1.context_id
+
+        r2 = await cluster.replica_b.on_message_send(
+            build_send_request(
+                'a1', task_id=task_id, context_id=context_id, message_id='m2'
+            ),
+            ctx,
+        )
+        assert r2.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        stored = await cluster.replica_a.task_store.get(task_id, ctx)
+        assert stored is not None
+        assert (
+            sum(1 for m in stored.task.history if m.role == Role.ROLE_USER) == 2
+        )
+
+        r3 = await cluster.replica_a.on_message_send(
+            build_send_request(
+                'a2', task_id=task_id, context_id=context_id, message_id='m3'
+            ),
+            ctx,
+        )
+        assert r3.status.state == TaskState.TASK_STATE_COMPLETED
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_resubscribe_on_non_owning_replica_streams_events(
+    dsn: str,
+) -> None:
+    """Replica A runs the agent; replica B resubscribes and streams via the DB."""
+    agent = ControlledAgent()
+    cluster = Cluster(dsn, agent, ControlledAgent())
+    ctx = make_context()
+    try:
+        # Task id comes from the first streamed event; the rest is consumed in
+        # the background so the agent runs on and the stream is seen to end.
+        stream = cluster.replica_a.on_message_send_stream(
+            build_send_request('go', message_id='m1'), ctx
+        )
+        first = await asyncio.wait_for(anext(stream), timeout=10)
+        task_id = first.id
+
+        async def finish_a_stream() -> None:
+            async for _ in stream:
+                pass
+
+        a_task = asyncio.create_task(finish_a_stream())
+        await asyncio.wait_for(agent.working.wait(), timeout=10)
+        await wait_for_state(
+            cluster.replica_b.task_store,
+            task_id,
+            TaskState.TASK_STATE_WORKING,
+            ctx,
+        )
+
+        states: list = []
+
+        async def observe() -> None:
+            async for ev in cluster.replica_b.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=task_id), ctx
+            ):
+                if getattr(ev, 'status', None):
+                    states.append(ev.status.state)
+                    if ev.status.state == TaskState.TASK_STATE_COMPLETED:
+                        return
+
+        observer = asyncio.create_task(observe())
+        await asyncio.sleep(0.2)  # let B read snapshot + start tailing the log
+        agent.release.set()
+
+        await asyncio.wait_for(observer, timeout=30)
+        await asyncio.wait_for(a_task, timeout=30)
+
+        assert states[0] == TaskState.TASK_STATE_WORKING
+        assert states[-1] == TaskState.TASK_STATE_COMPLETED
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_resubscribe_terminal_task_rejected(dsn: str) -> None:
+    """Resubscribe to a finished task is rejected (no hang), from any replica."""
+    agent = ControlledAgent()
+    agent.release.set()  # completes immediately
+    cluster = Cluster(dsn, agent, ControlledAgent())
+    ctx = make_context()
+    try:
+        result = await cluster.replica_a.on_message_send(
+            build_send_request('go', message_id='m1'), ctx
+        )
+        assert result.status.state == TaskState.TASK_STATE_COMPLETED
+
+        # A terminal task is rejected by the non-owning replica, not hung.
+        with pytest.raises(UnsupportedOperationError, match='terminal state'):
+            async for _ in cluster.replica_b.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=result.id), ctx
+            ):
+                pass
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_cancel_from_non_owning_replica_stops_remote_agent(
+    dsn: str,
+) -> None:
+    """Cancel on replica B stops the agent running on replica A (via CAS)."""
+    agent = LongRunningAgent()
+    cluster = Cluster(dsn, agent, LongRunningAgent())
+    ctx = make_context()
+    try:
+        # Task id from the first streamed event; the rest is consumed in the
+        # background so the agent keeps ticking and the stream is seen to end.
+        stream = cluster.replica_a.on_message_send_stream(
+            build_send_request('go', message_id='m1'), ctx
+        )
+        first = await asyncio.wait_for(anext(stream), timeout=10)
+        task_id = first.id
+
+        async def finish_a_stream() -> None:
+            async for _ in stream:
+                pass
+
+        a_task = asyncio.create_task(finish_a_stream())
+        await asyncio.wait_for(agent.working.wait(), timeout=10)
+        await wait_for_state(
+            cluster.replica_b.task_store,
+            task_id,
+            TaskState.TASK_STATE_WORKING,
+            ctx,
+        )
+
+        result = await cluster.replica_b.on_cancel_task(
+            CancelTaskRequest(id=task_id), ctx
+        )
+        assert result.status.state == TaskState.TASK_STATE_CANCELED
+
+        await asyncio.wait_for(agent.aborted.wait(), timeout=30)
+        await asyncio.wait_for(a_task, timeout=30)
+
+        final = await cluster.replica_b.task_store.get(task_id, ctx)
+        assert final is not None
+        assert final.task.status.state == TaskState.TASK_STATE_CANCELED
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_cancel_of_completed_task_is_not_cancelable(dsn: str) -> None:
+    """Cancelling a completed task from another replica is not cancelable."""
+    cluster = Cluster(dsn, CompletingAgent(), CompletingAgent())
+    ctx = make_context()
+    try:
+        result = await cluster.replica_a.on_message_send(
+            build_send_request('go', message_id='m1'), ctx
+        )
+        assert result.status.state == TaskState.TASK_STATE_COMPLETED
+        # Completed -> not cancelable, from the other replica.
+        with pytest.raises(TaskNotCancelableError):
+            await cluster.replica_b.on_cancel_task(
+                CancelTaskRequest(id=result.id), ctx
+            )
+    finally:
+        await cluster.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_absent_and_non_owner_rejected(dsn: str) -> None:
+    """Absent task -> NotFound; a non-owner cannot see another user's task."""
+    cluster = Cluster(dsn, CompletingAgent(), CompletingAgent())
+    try:
+        # Absent task on either replica.
+        with pytest.raises(TaskNotFoundError):
+            await cluster.replica_b.on_get_task(
+                GetTaskRequest(id='does-not-exist'), make_context()
+            )
+
+        # Owner-scoping: bob cannot get/subscribe/cancel alice's task.
+        result = await cluster.replica_a.on_message_send(
+            build_send_request('go', message_id='m1'), make_context('alice')
+        )
+        bob = make_context('bob')
+        with pytest.raises(TaskNotFoundError):
+            await cluster.replica_b.on_get_task(
+                GetTaskRequest(id=result.id), bob
+            )
+        with pytest.raises(TaskNotFoundError):
+            async for _ in cluster.replica_b.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=result.id), bob
+            ):
+                pass
+        with pytest.raises(TaskNotFoundError):
+            await cluster.replica_b.on_cancel_task(
+                CancelTaskRequest(id=result.id), bob
+            )
+    finally:
+        await cluster.aclose()
diff --git a/tests/integration/test_plugins.py b/tests/integration/test_plugins.py
new file mode 100644
index 000000000..c5f1d47a7
--- /dev/null
+++ b/tests/integration/test_plugins.py
@@ -0,0 +1,405 @@
+"""Plugins over real transports: JSON-RPC, HTTP+JSON, gRPC and v0.3 JSON-RPC."""
+
+import asyncio
+import contextvars
+
+from collections.abc import AsyncGenerator, Callable
+from typing import Any, NamedTuple
+
+import grpc
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a import plugins
+from a2a.client import ClientConfig, ClientFactory
+from a2a.client.base_client import BaseClient
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.plugins import (
+    ClientRequest,
+    ClientResponse,
+    CompletePlugin,
+    ExecutionPlugin,
+    ServerRequest,
+    ServerResponse,
+    TaskEventInfo,
+    TaskObserverPlugin,
+)
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandlerV2, GrpcHandler
+from a2a.server.routes import (
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.server.tasks import InMemoryTaskStore, TaskUpdater
+from a2a.types import a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    TaskState,
+)
+from a2a.utils import TransportProtocol
+from starlette.applications import Starlette
+
+
+class Recorder(CompletePlugin, ExecutionPlugin, TaskObserverPlugin):
+    """Records hooks and adds an ``x-trace`` header to outgoing calls."""
+
+    name = 'recorder'
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, Any]] = []
+
+    def hooks(self, name: str) -> list[Any]:
+        return [arg for hook, arg in self.calls if hook == name]
+
+    async def before_handler_run(self, request: ServerRequest) -> None:
+        self.calls.append(('before_handler_run', request))
+
+    async def after_handler_run(self, response: ServerResponse) -> None:
+        self.calls.append(('after_handler_run', response))
+
+    async def before_client_request(self, request: ClientRequest) -> None:
+        params = dict(request.context.service_parameters or {})
+        params['x-trace'] = 'trace-123'
+        request.context.service_parameters = params
+        self.calls.append(('before_client_request', request))
+
+    async def after_client_request(self, response: ClientResponse) -> None:
+        self.calls.append(('after_client_request', response))
+
+    async def before_execution(self, request_context: RequestContext) -> None:
+        self.calls.append(('before_execution', request_context))
+
+    async def on_execution_event(self, request_context, event) -> None:
+        self.calls.append(('on_execution_event', event))
+
+    async def after_execution(self, request_context, error) -> None:
+        self.calls.append(('after_execution', error))
+
+    async def on_task_event(self, info: TaskEventInfo) -> None:
+        self.calls.append(('on_task_event', info))
+
+
+class TaskAgent(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = context.current_task or new_task_from_user_message(
+            context.message
+        )
+        if not context.current_task:
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.start_work()
+        await updater.add_artifact(parts=[Part(text='done')], name='out')
+        await updater.complete()
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+def agent_card(grpc_url: str = 'localhost:0') -> AgentCard:
+    return AgentCard(
+        name='Plugin Agent',
+        description='Integration test agent',
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.HTTP_JSON,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://testserver',
+            ),
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC, url=grpc_url
+            ),
+        ],
+    )
+
+
+def send_request(text: str = 'hello') -> SendMessageRequest:
+    return SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='m-1', parts=[Part(text=text)]
+        )
+    )
+
+
+def incoming_headers(context: ServerCallContext) -> dict[str, str]:
+    """Request headers: state['headers'] for HTTP, metadata for gRPC."""
+    if 'grpc_context' in context.state:
+        return dict(context.state['grpc_context'].invocation_metadata())
+    return context.state['headers']
+
+
+async def wait_for(predicate: Callable[[], bool], timeout: float = 5) -> None:
+    async def poll() -> None:
+        while not predicate():
+            await asyncio.sleep(0.01)
+
+    await asyncio.wait_for(poll(), timeout)
+
+
+class Setup(NamedTuple):
+    client: BaseClient
+    server: Recorder
+    caller: Recorder
+    transport: str
+
+
+def http_app(handler: DefaultRequestHandlerV2, card: AgentCard) -> Starlette:
+    return Starlette(
+        routes=[
+            *create_agent_card_routes(agent_card=card, card_url='/card'),
+            *create_jsonrpc_routes(
+                request_handler=handler, rpc_url='/', enable_v0_3_compat=True
+            ),
+            *create_rest_routes(request_handler=handler),
+        ]
+    )
+
+
+@pytest.fixture(autouse=True)
+def restore_global():
+    previous = plugins.get_global()
+    yield
+    plugins.set_global(previous)
+
+
+@pytest_asyncio.fixture(
+    params=[
+        pytest.param(TransportProtocol.JSONRPC, id='JSON-RPC'),
+        pytest.param(TransportProtocol.HTTP_JSON, id='HTTP+JSON'),
+        pytest.param(TransportProtocol.GRPC, id='gRPC'),
+    ]
+)
+async def setup(request) -> AsyncGenerator[Setup, None]:
+    transport = request.param
+    server_recorder, caller_recorder = Recorder(), Recorder()
+    server = None
+    card = agent_card()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=TaskAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=card,
+        plugins=plugins.sequential(server_recorder),
+    )
+    # Clients pick up the global manager when created.
+    plugins.set_global(plugins.sequential(caller_recorder))
+
+    if transport == TransportProtocol.GRPC:
+        server = grpc.aio.server()
+        port = server.add_insecure_port('[::]:0')
+        card = agent_card(f'localhost:{port}')
+        a2a_pb2_grpc.add_A2AServiceServicer_to_server(
+            GrpcHandler(handler), server
+        )
+        await server.start()
+        config = ClientConfig(
+            grpc_channel_factory=grpc.aio.insecure_channel,
+            supported_protocol_bindings=[transport],
+        )
+    else:
+        config = ClientConfig(
+            httpx_client=httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=http_app(handler, card)),
+                base_url='http://testserver',
+            ),
+            supported_protocol_bindings=[transport],
+        )
+
+    client = ClientFactory(config).create(card)
+    yield Setup(client, server_recorder, caller_recorder, transport)
+
+    await client.close()
+    if server is not None:
+        await server.stop(0)
+
+
+@pytest.mark.asyncio
+async def test_streaming_message_runs_hooks_on_both_sides(setup: Setup):
+    events = [e async for e in setup.client.send_message(send_request())]
+    await wait_for(lambda: bool(setup.server.hooks('after_execution')))
+
+    assert events[-1].status_update.status.state == (
+        TaskState.TASK_STATE_COMPLETED
+    )
+
+    # Client side.
+    (call,) = setup.caller.hooks('before_client_request')
+    assert call.method == 'send_message_streaming'
+    client_responses = setup.caller.hooks('after_client_request')
+    assert len(client_responses) == len(events) + 1
+    assert client_responses[-1].is_final
+
+    # Server side: the header added by the client plugin arrives.
+    (run,) = setup.server.hooks('before_handler_run')
+    assert run.method == 'send_message_streaming'
+    assert incoming_headers(run.context)['x-trace'] == 'trace-123'
+    assert run.agent_card.name == 'Plugin Agent'
+    server_responses = setup.server.hooks('after_handler_run')
+    assert server_responses[-1].is_final
+    assert sum(r.is_stream_event for r in server_responses) == len(events)
+
+    # Execution and task hooks.
+    assert len(setup.server.hooks('on_execution_event')) == 4
+    transitions = [
+        (i.from_state, i.to_state) for i in setup.server.hooks('on_task_event')
+    ]
+    assert transitions[0] == (None, TaskState.TASK_STATE_SUBMITTED)
+    assert transitions[-1][1] == TaskState.TASK_STATE_COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_unary_call_runs_hooks_on_both_sides(setup: Setup):
+    events = [e async for e in setup.client.send_message(send_request())]
+    task_id = events[0].task.id
+    setup.server.calls.clear()
+    setup.caller.calls.clear()
+
+    task = await setup.client.get_task(GetTaskRequest(id=task_id))
+
+    assert task.id == task_id
+    assert [r.method for r in setup.caller.hooks('before_client_request')] == [
+        'get_task'
+    ]
+    (response,) = setup.server.hooks('after_handler_run')
+    assert response.method == 'get_task'
+    assert response.payload.id == task_id
+    assert response.is_final
+
+
+@pytest.mark.asyncio
+async def test_v03_jsonrpc_requests_run_server_hooks():
+    recorder = Recorder()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=TaskAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=agent_card(),
+        plugins=plugins.sequential(recorder),
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=http_app(handler, agent_card())),
+        base_url='http://testserver',
+    ) as http:
+        response = await http.post(
+            '/',
+            json={
+                'jsonrpc': '2.0',
+                'id': '1',
+                'method': 'message/send',
+                'params': {
+                    'message': {
+                        'messageId': 'm-03',
+                        'role': 'user',
+                        'parts': [{'kind': 'text', 'text': 'hello'}],
+                    }
+                },
+            },
+        )
+
+    assert response.status_code == 200
+    assert response.json()['result']['status']['state'] == 'completed'
+    (run,) = recorder.hooks('before_handler_run')
+    assert run.method == 'send_message'
+    assert recorder.hooks('after_handler_run')[-1].is_final
+
+
+_tenant: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    'tenant', default=None
+)
+
+
+class TenantPlugin(CompletePlugin, ExecutionPlugin):
+    """Forwards the incoming x-tenant header to outgoing calls."""
+
+    name = 'tenant'
+
+    async def before_execution(self, request_context: RequestContext) -> None:
+        headers = request_context.call_context.state.get('headers', {})
+        _tenant.set(headers.get('x-tenant'))
+
+    async def before_client_request(self, request: ClientRequest) -> None:
+        if tenant := _tenant.get():
+            params = dict(request.context.service_parameters or {})
+            params['x-tenant'] = tenant
+            request.context.service_parameters = params
+
+
+@pytest.mark.asyncio
+async def test_two_agent_chain_propagates_state_through_execution():
+    downstream = Recorder()
+    downstream_handler = DefaultRequestHandlerV2(
+        agent_executor=TaskAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=agent_card(),
+        plugins=plugins.sequential(downstream),
+    )
+    downstream_http = httpx.AsyncClient(
+        transport=httpx.ASGITransport(
+            app=http_app(downstream_handler, agent_card())
+        ),
+        base_url='http://testserver',
+    )
+    tenant_plugin = TenantPlugin()
+    plugins.set_global(plugins.sequential(tenant_plugin))
+
+    class Orchestrator(AgentExecutor):
+        async def execute(self, context, event_queue):
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+            client = ClientFactory(
+                ClientConfig(httpx_client=downstream_http)
+            ).create(agent_card())
+            async for _ in client.send_message(send_request('forwarded')):
+                pass
+            await TaskUpdater(event_queue, task.id, task.context_id).complete()
+
+        async def cancel(self, context, event_queue):
+            pass
+
+    upstream_handler = DefaultRequestHandlerV2(
+        agent_executor=Orchestrator(),
+        task_store=InMemoryTaskStore(),
+        agent_card=agent_card(),
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(
+            app=http_app(upstream_handler, agent_card())
+        ),
+        base_url='http://testserver',
+    ) as http:
+        response = await http.post(
+            '/',
+            headers={'x-tenant': 'acme', 'A2A-Version': '1.0'},
+            json={
+                'jsonrpc': '2.0',
+                'id': '1',
+                'method': 'SendMessage',
+                'params': {
+                    'message': {
+                        'messageId': 'm-up',
+                        'role': 'ROLE_USER',
+                        'parts': [{'text': 'plan'}],
+                    }
+                },
+            },
+        )
+    await downstream_http.aclose()
+
+    assert response.status_code == 200, response.text
+    (run,) = downstream.hooks('before_handler_run')
+    assert run.context.state['headers']['x-tenant'] == 'acme'
diff --git a/tests/integration/test_samples_smoke.py b/tests/integration/test_samples_smoke.py
new file mode 100644
index 000000000..fcb49a003
--- /dev/null
+++ b/tests/integration/test_samples_smoke.py
@@ -0,0 +1,134 @@
+"""End-to-end smoke test for `samples/hello_world_agent.py` and `samples/cli.py`.
+
+Boots the sample agent as a subprocess on free ports, then runs the sample CLI
+against it once per supported transport, asserting the expected greeting reply
+flows through.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import socket
+import sys
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import httpx
+import pytest
+import pytest_asyncio
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SAMPLES_DIR = REPO_ROOT / 'samples'
+AGENT_SCRIPT = SAMPLES_DIR / 'hello_world_agent.py'
+CLI_SCRIPT = SAMPLES_DIR / 'cli.py'
+
+STARTUP_TIMEOUT_S = 30.0
+CLI_TIMEOUT_S = 30.0
+EXPECTED_REPLY = 'Hello World! Nice to meet you!'
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(('127.0.0.1', 0))
+        return sock.getsockname()[1]
+
+
+async def _wait_for_agent_card(url: str) -> None:
+    deadline = asyncio.get_running_loop().time() + STARTUP_TIMEOUT_S
+    async with httpx.AsyncClient(timeout=2.0) as client:
+        while asyncio.get_running_loop().time() < deadline:
+            try:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    return
+            except httpx.RequestError:
+                pass
+            await asyncio.sleep(0.2)
+    raise TimeoutError(f'Agent did not become ready at {url}')
+
+
+@pytest_asyncio.fixture
+async def running_sample_agent() -> AsyncGenerator[str, None]:
+    """Start `hello_world_agent.py` as a subprocess on free ports."""
+    host = '127.0.0.1'
+    http_port = _free_port()
+    grpc_port = _free_port()
+    compat_grpc_port = _free_port()
+    base_url = f'http://{host}:{http_port}'
+
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(AGENT_SCRIPT),
+        '--host',
+        host,
+        '--port',
+        str(http_port),
+        '--grpc-port',
+        str(grpc_port),
+        '--compat-grpc-port',
+        str(compat_grpc_port),
+        cwd=str(REPO_ROOT),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+    try:
+        await _wait_for_agent_card(f'{base_url}/.well-known/agent-card.json')
+        yield base_url
+    finally:
+        if proc.returncode is None:
+            proc.terminate()
+            try:
+                await asyncio.wait_for(proc.wait(), timeout=10.0)
+            except asyncio.TimeoutError:
+                proc.kill()
+                await proc.wait()
+
+
+async def _run_cli(base_url: str, transport: str) -> str:
+    """Run `cli.py --transport <transport>`, send `hello`, return combined output."""
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(CLI_SCRIPT),
+        '--url',
+        base_url,
+        '--transport',
+        transport,
+        cwd=str(REPO_ROOT),
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(
+            proc.communicate(b'hello\n/quit\n'),
+            timeout=CLI_TIMEOUT_S,
+        )
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise
+    output = stdout.decode('utf-8', errors='replace')
+    assert proc.returncode == 0, (
+        f'CLI exited with {proc.returncode} for transport {transport!r}.\n'
+        f'Output:\n{output}'
+    )
+    return output
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('transport', ['JSONRPC', 'HTTP+JSON', 'GRPC'])
+async def test_cli_against_sample_agent(
+    running_sample_agent: str, transport: str
+) -> None:
+    """The CLI should successfully exchange a greeting over each transport."""
+    output = await _run_cli(running_sample_agent, transport)
+
+    assert 'TASK_STATE_COMPLETED' in output, output
+    assert EXPECTED_REPLY in output, output
diff --git a/tests/integration/test_scenarios.py b/tests/integration/test_scenarios.py
new file mode 100644
index 000000000..9a51bd1e4
--- /dev/null
+++ b/tests/integration/test_scenarios.py
@@ -0,0 +1,2472 @@
+import asyncio
+import collections
+import logging
+
+from collections.abc import AsyncIterator
+from contextlib import AsyncExitStack
+from typing import Any, NamedTuple
+
+import grpc
+import httpx
+import pytest
+import pytest_asyncio
+
+from a2a.auth.user import User
+from a2a.client.client import Client, ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.client.errors import A2AClientError
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import (
+    DefaultRequestHandlerV2,
+    GrpcHandler,
+    GrpcServerCallContextBuilder,
+    RequestHandler,
+)
+from a2a.server.request_handlers.default_request_handler import (
+    LegacyRequestHandler,
+)
+from a2a.server.routes.common import DefaultServerCallContextBuilder
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import a2a_pb2_grpc
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Artifact,
+    CancelTaskRequest,
+    GetTaskRequest,
+    ListTasksRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils import TransportProtocol
+from a2a.utils.constants import TERMINAL_TASK_STATES
+from a2a.utils.errors import (
+    InvalidAgentResponseError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from starlette.applications import Starlette
+from starlette.requests import Request
+
+
+logger = logging.getLogger(__name__)
+
+
+async def wait_for_state(
+    client: Any,
+    task_id: str,
+    expected_states: set[TaskState.ValueType],
+    timeout: float = 1.0,
+) -> None:
+    """Wait for the task to reach one of the expected states."""
+    start_time = asyncio.get_event_loop().time()
+    while True:
+        task = await client.get_task(GetTaskRequest(id=task_id))
+        if task.status.state in expected_states:
+            return
+
+        if asyncio.get_event_loop().time() - start_time > timeout:
+            raise TimeoutError(
+                f'Task {task_id} did not reach expected states {expected_states} within {timeout}s. '
+                f'Current state: {task.status.state}'
+            )
+        await asyncio.sleep(0.01)
+
+
+async def get_all_events(stream):
+    return [event async for event in stream]
+
+
+class MockUser(User):
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return 'test-user'
+
+
+class MockCallContextBuilder(GrpcServerCallContextBuilder):
+    def build(self, request: Any) -> ServerCallContext:
+        return ServerCallContext(
+            user=MockUser(), state={'headers': {'a2a-version': '1.0'}}
+        )
+
+
+class MockHttpCallContextBuilder(DefaultServerCallContextBuilder):
+    def build_user(self, request: Request) -> User:
+        """Uses the same test identity as the gRPC setup."""
+        return MockUser()
+
+
+class InputRequiredAgent(AgentExecutor):
+    """Test agent: 'start' -> INPUT_REQUIRED, anything else -> COMPLETED."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        message = context.message
+        if message and message.parts and message.parts[0].text == 'start':
+            task = new_task_from_user_message(message)
+            task.status.state = TaskState.TASK_STATE_INPUT_REQUIRED
+            await event_queue.enqueue_event(task)
+        else:
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+def agent_card():
+    return AgentCard(
+        name='Test Agent',
+        version='1.0.0',
+        capabilities=AgentCapabilities(streaming=True),
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.GRPC,
+                url='http://testserver',
+            )
+        ],
+    )
+
+
+def get_task_id(event):
+    if event.HasField('task'):
+        return event.task.id
+    if event.HasField('status_update'):
+        return event.status_update.task_id
+    assert False, f'Event {event} has no task_id'
+
+
+def get_task_context_id(event):
+    if event.HasField('task'):
+        return event.task.context_id
+    if event.HasField('status_update'):
+        return event.status_update.context_id
+    assert False, f'Event {event} has no context_id'
+
+
+def get_state(event):
+    if event.HasField('task'):
+        return event.task.status.state
+    return event.status_update.status.state
+
+
+def validate_state(event, expected_state):
+    assert get_state(event) == expected_state
+
+
+class RestSetup(NamedTuple):
+    app: Starlette
+    httpx_client: httpx.AsyncClient
+
+
+@pytest_asyncio.fixture(scope='module')
+async def rest_setup() -> AsyncIterator[RestSetup]:
+    app = Starlette()
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url='http://testserver'
+    ) as httpx_client:
+        yield RestSetup(app, httpx_client)
+
+
+_test_resources = AsyncExitStack()
+
+
+@pytest_asyncio.fixture(autouse=True)
+async def cleanup_test_servers() -> AsyncIterator[None]:
+    try:
+        yield
+    finally:
+        await _test_resources.aclose()
+
+
+async def close_scenario_handler(handler: RequestHandler) -> None:
+    """Stops agent work owned by a scenario, including legacy background work."""
+    if isinstance(handler, DefaultRequestHandlerV2):
+        await handler.aclose()
+    elif isinstance(handler, LegacyRequestHandler):
+        with handler._running_agents_lock:
+            producers = list(handler._running_agents.values())
+        for producer in producers:
+            producer.cancel()
+        if producers:
+            await asyncio.gather(*producers, return_exceptions=True)
+        background_tasks = list(handler._background_tasks)
+        if background_tasks:
+            await asyncio.gather(*background_tasks, return_exceptions=True)
+
+
+async def create_client(
+    handler: RequestHandler,
+    agent_card: AgentCard,
+    streaming: bool = False,
+    *,
+    transport: TransportProtocol = TransportProtocol.GRPC,
+    rest_setup: RestSetup | None = None,
+) -> Client:
+    """Creates a client for a scenario test."""
+    if transport not in (TransportProtocol.GRPC, TransportProtocol.HTTP_JSON):
+        raise ValueError(f'Unsupported scenario transport: {transport}')
+
+    async with AsyncExitStack() as resources:
+        resources.push_async_callback(close_scenario_handler, handler)
+
+        if transport == TransportProtocol.HTTP_JSON:
+            if rest_setup is None:
+                raise ValueError(
+                    'REST scenarios require the rest_setup fixture'
+                )
+            rest_setup.app.router.routes[:] = create_rest_routes(
+                request_handler=handler,
+                context_builder=MockHttpCallContextBuilder(),
+            )
+            resources.callback(rest_setup.app.router.routes.clear)
+            server_address = 'http://testserver'
+            config = ClientConfig(
+                httpx_client=rest_setup.httpx_client,
+                supported_protocol_bindings=[transport],
+                streaming=streaming,
+            )
+        else:
+            server = grpc.aio.server()
+            resources.push_async_callback(server.stop, None)
+            port = server.add_insecure_port('[::]:0')
+            server_address = f'localhost:{port}'
+
+            servicer = GrpcHandler(
+                request_handler=handler,
+                context_builder=MockCallContextBuilder(),
+            )
+            a2a_pb2_grpc.add_A2AServiceServicer_to_server(servicer, server)
+            await server.start()
+            config = ClientConfig(
+                grpc_channel_factory=grpc.aio.insecure_channel,
+                supported_protocol_bindings=[transport],
+                streaming=streaming,
+            )
+
+        agent_card.supported_interfaces[0].url = server_address
+        agent_card.supported_interfaces[0].protocol_binding = transport
+
+        factory = ClientFactory(config=config)
+        client = factory.create(agent_card)
+        resources.push_async_callback(client.close)
+        _test_resources.push_async_callback(resources.pop_all().aclose)
+        return client
+
+
+def create_handler(
+    agent_executor, use_legacy, task_store=None, queue_manager=None
+):
+    task_store = task_store or InMemoryTaskStore()
+    queue_manager = queue_manager or InMemoryQueueManager()
+    return (
+        LegacyRequestHandler(
+            agent_executor,
+            task_store,
+            agent_card(),
+            queue_manager,
+        )
+        if use_legacy
+        else DefaultRequestHandlerV2(
+            agent_executor,
+            task_store,
+            agent_card(),
+            queue_manager,
+        )
+    )
+
+
+# Scenario 1: Cancellation of already terminal task
+# This also covers test_scenario_7_cancel_terminal_task from test_handler_comparison
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'transport',
+    [TransportProtocol.GRPC, TransportProtocol.HTTP_JSON],
+    ids=['grpc', 'rest'],
+)
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_1_cancel_terminal_task(
+    use_legacy: bool,
+    streaming: bool,
+    transport: TransportProtocol,
+    rest_setup: RestSetup,
+) -> None:
+    class DummyAgentExecutor(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            pass
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            pass
+
+    task_store = InMemoryTaskStore()
+    handler = create_handler(
+        DummyAgentExecutor(), use_legacy, task_store=task_store
+    )
+    client = await create_client(
+        handler,
+        agent_card=agent_card(),
+        streaming=streaming,
+        transport=transport,
+        rest_setup=rest_setup,
+    )
+
+    task_id = 'terminal-task'
+    await task_store.save(
+        Task(
+            id=task_id, status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED)
+        ),
+        ServerCallContext(user=MockUser()),
+    )
+    with pytest.raises(TaskNotCancelableError):
+        await client.cancel_task(CancelTaskRequest(id=task_id))
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'transport',
+    [TransportProtocol.GRPC, TransportProtocol.HTTP_JSON],
+    ids=['grpc', 'rest'],
+)
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+async def test_scenario_4_simple_streaming(
+    use_legacy: bool, transport: TransportProtocol, rest_setup: RestSetup
+) -> None:
+    class DummyAgentExecutor(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            pass
+
+    handler = create_handler(DummyAgentExecutor(), use_legacy)
+    client = await create_client(
+        handler,
+        agent_card=agent_card(),
+        streaming=True,
+        transport=transport,
+        rest_setup=rest_setup,
+    )
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+    events = [
+        event
+        async for event in client.send_message(SendMessageRequest(message=msg))
+    ]
+    task, status_update = events
+    assert task.HasField('task')
+    assert status_update.HasField('status_update')
+
+    assert [get_state(event) for event in events] == [
+        TaskState.TASK_STATE_WORKING,
+        TaskState.TASK_STATE_COMPLETED,
+    ]
+
+
+# Scenario 5: Re-subscribing to a finished task
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+async def test_scenario_5_resubscribe_to_finished(use_legacy):
+    class DummyAgentExecutor(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(DummyAgentExecutor(), use_legacy)
+    client = await create_client(handler, agent_card=agent_card())
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    (event,) = [event async for event in it]
+    task_id = event.task.id
+
+    await wait_for_state(
+        client, task_id, expected_states={TaskState.TASK_STATE_COMPLETED}
+    )
+    # TODO: Use different transport.
+    with pytest.raises(
+        NotImplementedError,
+        match='client and/or server do not support resubscription',
+    ):
+        async for _ in client.subscribe(SubscribeToTaskRequest(id=task_id)):
+            pass
+
+
+# Scenario 6-8: Parity for Error cases
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenarios_simple_errors(use_legacy, streaming):
+    class DummyAgentExecutor(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_COMPLETED
+            await event_queue.enqueue_event(task)
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(DummyAgentExecutor(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    with pytest.raises(TaskNotFoundError):
+        await client.get_task(GetTaskRequest(id='missing'))
+
+    msg1 = Message(
+        task_id='missing',
+        message_id='missing-task',
+        role=Role.ROLE_USER,
+        parts=[Part(text='h')],
+    )
+    with pytest.raises(TaskNotFoundError):
+        async for _ in client.send_message(SendMessageRequest(message=msg1)):
+            pass
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    (event,) = [event async for event in it]
+
+    if streaming:
+        assert event.HasField('task')
+        task_id = event.task.id
+        validate_state(event, TaskState.TASK_STATE_COMPLETED)
+    else:
+        assert event.HasField('task')
+        task_id = event.task.id
+        assert event.task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    logger.info('Sending message to completed task %s', task_id)
+    msg2 = Message(
+        message_id='test-msg-2',
+        task_id=task_id,
+        role=Role.ROLE_USER,
+        parts=[Part(text='message to completed task')],
+    )
+    # Spec 3.1.1: messages sent to a task in a terminal state are rejected
+    # with UnsupportedOperationError.
+    with pytest.raises(UnsupportedOperationError):
+        async for _ in client.send_message(SendMessageRequest(message=msg2)):
+            pass
+
+    (task,) = (await client.list_tasks(ListTasksRequest())).tasks
+    assert task.status.state == TaskState.TASK_STATE_COMPLETED
+    (message,) = task.history
+    assert message.role == Role.ROLE_USER
+    (message_part,) = message.parts
+    assert message_part.text == 'hello'
+
+
+# Scenario 9: Exception before any event.
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_9_error_before_blocking(use_legacy, streaming):
+    class ErrorBeforeAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            raise ValueError('TEST_ERROR_IN_EXECUTE')
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ErrorBeforeAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    # TODO: Is it correct error code ?
+    with pytest.raises(A2AClientError, match='TEST_ERROR_IN_EXECUTE'):
+        async for _ in client.send_message(
+            SendMessageRequest(
+                message=msg,
+                configuration=SendMessageConfiguration(
+                    return_immediately=False
+                ),
+            )
+        ):
+            pass
+
+    if use_legacy:
+        # Legacy is not creating tasks for agent failures.
+        assert len((await client.list_tasks(ListTasksRequest())).tasks) == 0
+    else:
+        (task,) = (await client.list_tasks(ListTasksRequest())).tasks
+        assert task.status.state == TaskState.TASK_STATE_FAILED
+
+        if streaming:
+            with pytest.raises(
+                UnsupportedOperationError,
+                match='Task .* is in terminal state: TASK_STATE_FAILED',
+            ):
+                await client.subscribe(
+                    SubscribeToTaskRequest(id=task.id)
+                ).__anext__()
+
+
+# Scenario 12/13: Exception after initial event
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_12_13_error_after_initial_event(use_legacy, streaming):
+    started_event = asyncio.Event()
+    continue_event = asyncio.Event()
+
+    class ErrorAfterAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await continue_event.wait()
+            raise ValueError('TEST_ERROR_IN_EXECUTE')
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ErrorAfterAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    it = client.send_message(SendMessageRequest(message=msg))
+
+    tasks = []
+
+    if streaming:
+        res = await it.__anext__()
+        validate_state(res, TaskState.TASK_STATE_WORKING)
+        continue_event.set()
+    else:
+
+        async def release_agent():
+            await started_event.wait()
+            continue_event.set()
+
+        tasks.append(asyncio.create_task(release_agent()))
+
+    with pytest.raises(A2AClientError, match='TEST_ERROR_IN_EXECUTE'):
+        async for _ in it:
+            pass
+
+    await asyncio.gather(*tasks)
+
+    (task,) = (await client.list_tasks(ListTasksRequest())).tasks
+    if use_legacy:
+        # Legacy does not update task state on exception.
+        assert task.status.state == TaskState.TASK_STATE_WORKING
+    else:
+        assert task.status.state == TaskState.TASK_STATE_FAILED
+
+
+# Scenario 14: Exception in Cancel
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_14_error_in_cancel(use_legacy, streaming):
+    started_event = asyncio.Event()
+    hang_event = asyncio.Event()
+
+    class ErrorCancelAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await hang_event.wait()
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            raise ValueError('TEST_ERROR_IN_CANCEL')
+
+    handler = create_handler(ErrorCancelAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg',
+        role=Role.ROLE_USER,
+        parts=[Part(text='hello')],
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    res = await it.__anext__()
+    task_id = res.task.id if res.HasField('task') else res.status_update.task_id
+
+    await asyncio.wait_for(started_event.wait(), timeout=1.0)
+
+    with pytest.raises(A2AClientError, match='TEST_ERROR_IN_CANCEL'):
+        await client.cancel_task(CancelTaskRequest(id=task_id))
+
+    (task,) = (await client.list_tasks(ListTasksRequest())).tasks
+    if use_legacy:
+        # Legacy does not update task state on exception.
+        assert task.status.state == TaskState.TASK_STATE_WORKING
+    else:
+        assert task.status.state == TaskState.TASK_STATE_FAILED
+
+
+# Scenario 15: Subscribe to task that errors out
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+async def test_scenario_15_subscribe_error(use_legacy):
+    started_event = asyncio.Event()
+    continue_event = asyncio.Event()
+
+    class ErrorAfterAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await continue_event.wait()
+            raise ValueError('TEST_ERROR_IN_EXECUTE')
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ErrorAfterAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=True
+    )
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    it_start = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    res = await it_start.__anext__()
+    task_id = res.task.id if res.HasField('task') else res.status_update.task_id
+
+    async def consume_events():
+        async for _ in client.subscribe(SubscribeToTaskRequest(id=task_id)):
+            pass
+
+    consume_task = asyncio.create_task(consume_events())
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(asyncio.shield(consume_task), timeout=0.1)
+
+    await asyncio.wait_for(started_event.wait(), timeout=1.0)
+    continue_event.set()
+
+    if use_legacy:
+        # Legacy client hangs forever.
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(consume_task, timeout=0.1)
+    else:
+        with pytest.raises(A2AClientError, match='TEST_ERROR_IN_EXECUTE'):
+            await consume_task
+
+    (task,) = (await client.list_tasks(ListTasksRequest())).tasks
+    if use_legacy:
+        # Legacy does not update task state on exception.
+        assert task.status.state == TaskState.TASK_STATE_WORKING
+    else:
+        assert task.status.state == TaskState.TASK_STATE_FAILED
+
+
+# Scenario 16: Slow execution and return_immediately=True
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_16_slow_execution(use_legacy, streaming):
+    started_event = asyncio.Event()
+    hang_event = asyncio.Event()
+
+    class SlowAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            started_event.set()
+            await hang_event.wait()
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    queue_manager = InMemoryQueueManager()
+    handler = create_handler(
+        SlowAgent(), use_legacy, queue_manager=queue_manager
+    )
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg',
+        role=Role.ROLE_USER,
+        parts=[Part(text='hello')],
+    )
+
+    async def send_message_and_get_first_response():
+        it = client.send_message(
+            SendMessageRequest(
+                message=msg,
+                configuration=SendMessageConfiguration(return_immediately=True),
+            )
+        )
+        return await asyncio.wait_for(it.__anext__(), timeout=0.1)
+
+    # First response should not be there yet.
+    with pytest.raises(asyncio.TimeoutError):
+        await send_message_and_get_first_response()
+
+    tasks = (await client.list_tasks(ListTasksRequest())).tasks
+    assert len(tasks) == 0
+
+
+# Scenario 17: Cancellation of a working task.
+# @pytest.mark.skip
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_cancel_working_task_empty_cancel(use_legacy, streaming):
+    started_event = asyncio.Event()
+    hang_event = asyncio.Event()
+
+    class DummyCancelAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await hang_event.wait()
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            # TODO: this should be done automatically by the framework ?
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_CANCELED),
+                )
+            )
+
+    handler = create_handler(DummyCancelAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    res = await it.__anext__()
+    task_id = res.task.id if res.HasField('task') else res.status_update.task_id
+
+    await asyncio.wait_for(started_event.wait(), timeout=1.0)
+
+    task_before = await client.get_task(GetTaskRequest(id=task_id))
+    assert task_before.status.state == TaskState.TASK_STATE_WORKING
+
+    cancel_res = await client.cancel_task(CancelTaskRequest(id=task_id))
+    assert cancel_res.status.state == TaskState.TASK_STATE_CANCELED
+
+    task_after = await client.get_task(GetTaskRequest(id=task_id))
+    assert task_after.status.state == TaskState.TASK_STATE_CANCELED
+
+    (task_from_list,) = (await client.list_tasks(ListTasksRequest())).tasks
+    assert task_from_list.status.state == TaskState.TASK_STATE_CANCELED
+
+
+# Scenario 18: Complex streaming with multiple subscribers
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+async def test_scenario_18_streaming_subscribers(use_legacy):
+    started_event = asyncio.Event()
+    working_event = asyncio.Event()
+    completed_event = asyncio.Event()
+
+    class ComplexAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await working_event.wait()
+
+            await event_queue.enqueue_event(
+                TaskArtifactUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    artifact=Artifact(artifact_id='test-art'),
+                )
+            )
+            await completed_event.wait()
+
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ComplexAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=True
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    res = await it.__anext__()
+    task_id = res.task.id if res.HasField('task') else res.status_update.task_id
+
+    await asyncio.wait_for(started_event.wait(), timeout=1.0)
+
+    # create first subscriber
+    sub1 = client.subscribe(SubscribeToTaskRequest(id=task_id))
+
+    # first subscriber receives current task state (WORKING)
+    validate_state(await sub1.__anext__(), TaskState.TASK_STATE_WORKING)
+
+    # create second subscriber
+    sub2 = client.subscribe(SubscribeToTaskRequest(id=task_id))
+
+    # second subscriber receives current task state (WORKING)
+    validate_state(await sub2.__anext__(), TaskState.TASK_STATE_WORKING)
+
+    working_event.set()
+
+    # validate what both subscribers observed (artifact)
+    res1_art = await sub1.__anext__()
+    assert res1_art.artifact_update.artifact.artifact_id == 'test-art'
+
+    res2_art = await sub2.__anext__()
+    assert res2_art.artifact_update.artifact.artifact_id == 'test-art'
+
+    completed_event.set()
+
+    # validate what both subscribers observed (completed)
+    validate_state(await sub1.__anext__(), TaskState.TASK_STATE_COMPLETED)
+    validate_state(await sub2.__anext__(), TaskState.TASK_STATE_COMPLETED)
+
+    # validate final task state with getTask
+    final_task = await client.get_task(GetTaskRequest(id=task_id))
+    assert final_task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    (artifact,) = final_task.artifacts
+    assert artifact.artifact_id == 'test-art'
+
+    (message,) = final_task.history
+    assert message.parts[0].text == 'hello'
+
+
+# Scenario 19: Parallel executions for the same task should not happen simultaneously.
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_19_no_parallel_executions(use_legacy, streaming):
+    started_event = asyncio.Event()
+    continue_event = asyncio.Event()
+    executions_count = 0
+
+    class CountingAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            nonlocal executions_count
+            executions_count += 1
+
+            if executions_count > 1:
+                await event_queue.enqueue_event(
+                    TaskArtifactUpdateEvent(
+                        task_id=context.task_id,
+                        context_id=context.context_id,
+                        artifact=Artifact(artifact_id='SECOND_EXECUTION'),
+                    )
+                )
+                return
+
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started_event.set()
+            await continue_event.wait()
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(CountingAgent(), use_legacy)
+    client1 = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+    client2 = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg1 = Message(
+        message_id='test-msg-1',
+        role=Role.ROLE_USER,
+        parts=[Part(text='hello 1')],
+    )
+
+    # First client sends initial message
+    it1 = client1.send_message(
+        SendMessageRequest(
+            message=msg1,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    task1 = asyncio.create_task(it1.__anext__())
+
+    # Wait for the first execution to reach the WORKING state
+    await asyncio.wait_for(started_event.wait(), timeout=1.0)
+    assert executions_count == 1
+
+    # Extract task_id from the first call using list_tasks
+    (task,) = (await client1.list_tasks(ListTasksRequest())).tasks
+    task_id = task.id
+
+    msg2 = Message(
+        message_id='test-msg-2',
+        task_id=task_id,
+        role=Role.ROLE_USER,
+        parts=[Part(text='hello 2')],
+    )
+
+    # Second client sends a message to the same task
+    it2 = client2.send_message(
+        SendMessageRequest(
+            message=msg2,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    task2 = asyncio.create_task(it2.__anext__())
+
+    if use_legacy:
+        # Legacy handler executes the second request in parallel.
+        await task2
+        assert executions_count == 2
+    else:
+        # V2 handler queues the second request.
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(asyncio.shield(task2), timeout=0.1)
+        assert executions_count == 1
+
+    # Unblock AgentExecutor
+    continue_event.set()
+
+    # Verify that both calls for clients finished.
+    if use_legacy and not streaming:
+        # Legacy handler fails on first execution.
+        with pytest.raises(A2AClientError, match='NoTaskQueue'):
+            await task1
+    else:
+        await task1
+
+    try:
+        await task2
+    except StopAsyncIteration:
+        # TODO: Test is flaky. Debug it.
+        return
+
+    # Consume remaining events if any
+    async def consume(it):
+        async for _ in it:
+            pass
+
+    await asyncio.gather(consume(it1), consume(it2))
+    assert executions_count == 2
+
+    # Validate final task state.
+    final_task = await client1.get_task(GetTaskRequest(id=task_id))
+
+    if use_legacy:
+        # Legacy handler fails to complete the task.
+        assert final_task.status.state == TaskState.TASK_STATE_WORKING
+    else:
+        assert final_task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    # TODO: What is expected state of messages and artifacts?
+
+
+# Scenario: Validate return_immediately flag behaviour.
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_return_immediately(use_legacy, streaming):
+    class ImmediateAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ImmediateAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='hello')]
+    )
+
+    # Test non-blocking return.
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    states = [get_state(event) async for event in it]
+
+    if streaming:
+        assert states == [
+            TaskState.TASK_STATE_WORKING,
+            TaskState.TASK_STATE_COMPLETED,
+        ]
+    else:
+        assert states == [TaskState.TASK_STATE_WORKING]
+
+
+# Scenario: Test TASK_STATE_INPUT_REQUIRED.
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_resumption_from_interrupted(use_legacy, streaming):
+    handler = create_handler(InputRequiredAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    # First send message to get it into input required state
+    msg1 = Message(
+        message_id='msg-start', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg1,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    events1 = [event async for event in it]
+    assert [get_state(event) for event in events1] == [
+        TaskState.TASK_STATE_INPUT_REQUIRED,
+    ]
+    task_id = get_task_id(events1[0])
+    context_id = get_task_context_id(events1[0])
+
+    # Now send another message to resume
+    msg2 = Message(
+        task_id=task_id,
+        context_id=context_id,
+        message_id='msg-resume',
+        role=Role.ROLE_USER,
+        parts=[Part(text='here is input')],
+    )
+
+    it2 = client.send_message(
+        SendMessageRequest(
+            message=msg2,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    assert [get_state(event) async for event in it2] == [
+        TaskState.TASK_STATE_COMPLETED,
+    ]
+
+
+def test_input_required_followup_across_per_rpc_event_loops():
+    handler = create_handler(InputRequiredAgent(), use_legacy=False)
+    call_context = ServerCallContext(user=MockUser())
+
+    msg1 = Message(
+        message_id='msg-start', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+    req1 = SendMessageRequest(
+        message=msg1,
+        configuration=SendMessageConfiguration(return_immediately=False),
+    )
+    result1 = asyncio.run(handler.on_message_send(req1, call_context))
+    assert isinstance(result1, Task)
+    assert result1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    msg2 = Message(
+        task_id=result1.id,
+        context_id=result1.context_id,
+        message_id='msg-resume',
+        role=Role.ROLE_USER,
+        parts=[Part(text='here is input')],
+    )
+    req2 = SendMessageRequest(
+        message=msg2,
+        configuration=SendMessageConfiguration(return_immediately=False),
+    )
+    result2 = asyncio.run(handler.on_message_send(req2, call_context))
+    assert isinstance(result2, Task)
+    assert result2.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+# Scenario: Auth required and side channel unblocking
+# Migrated from: test_workflow_auth_required_side_channel in test_handler_comparison
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_auth_required_side_channel(use_legacy, streaming):
+    side_channel_event = asyncio.Event()
+
+    class AuthAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_AUTH_REQUIRED),
+                )
+            )
+
+            await side_channel_event.wait()
+
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(AuthAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    if streaming:
+        event1 = await asyncio.wait_for(it.__anext__(), timeout=1.0)
+        assert get_state(event1) == TaskState.TASK_STATE_WORKING
+
+        event2 = await asyncio.wait_for(it.__anext__(), timeout=1.0)
+        assert get_state(event2) == TaskState.TASK_STATE_AUTH_REQUIRED
+
+        task_id = event2.status_update.task_id
+
+        side_channel_event.set()
+
+        # Remaining event.
+        (event3,) = [event async for event in it]
+        assert get_state(event3) == TaskState.TASK_STATE_COMPLETED
+    else:
+        (event,) = [event async for event in it]
+        assert get_state(event) == TaskState.TASK_STATE_AUTH_REQUIRED
+        task_id = event.task.id
+
+        side_channel_event.set()
+
+        await wait_for_state(
+            client, task_id, expected_states={TaskState.TASK_STATE_COMPLETED}
+        )
+
+
+# Scenario: Auth required and in channel unblocking
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_auth_required_in_channel(use_legacy, streaming):
+    class AuthAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            message = context.message
+            if message and message.parts and message.parts[0].text == 'start':
+                task = new_task_from_user_message(message)
+                task.status.state = TaskState.TASK_STATE_AUTH_REQUIRED
+                await event_queue.enqueue_event(task)
+            elif (
+                message
+                and message.parts
+                and message.parts[0].text == 'credentials'
+            ):
+                await event_queue.enqueue_event(
+                    TaskStatusUpdateEvent(
+                        task_id=context.task_id,
+                        context_id=context.context_id,
+                        status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                    )
+                )
+
+            else:
+                raise ValueError(f'Unexpected message {message}')
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(AuthAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg1 = Message(
+        message_id='msg-start', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg1,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    events1 = [event async for event in it]
+    assert [get_state(event) for event in events1] == [
+        TaskState.TASK_STATE_AUTH_REQUIRED,
+    ]
+    task_id = get_task_id(events1[0])
+    context_id = get_task_context_id(events1[0])
+
+    # Now send another message with credentials
+    msg2 = Message(
+        task_id=task_id,
+        context_id=context_id,
+        message_id='msg-creds',
+        role=Role.ROLE_USER,
+        parts=[Part(text='credentials')],
+    )
+
+    it2 = client.send_message(
+        SendMessageRequest(
+            message=msg2,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+
+    assert [get_state(event) async for event in it2] == [
+        TaskState.TASK_STATE_COMPLETED,
+    ]
+
+
+# Scenario: Parallel subscribe attach detach
+# Migrated from: test_parallel_subscribe_attach_detach in test_handler_comparison
+@pytest.mark.timeout(5.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+async def test_scenario_parallel_subscribe_attach_detach(use_legacy):  # noqa: PLR0915
+    events = collections.defaultdict(asyncio.Event)
+
+    class EmitAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+
+            phases = [
+                ('trigger_phase_1', 'artifact_1'),
+                ('trigger_phase_2', 'artifact_2'),
+                ('trigger_phase_3', 'artifact_3'),
+                ('trigger_phase_4', 'artifact_4'),
+            ]
+
+            for trigger_name, artifact_id in phases:
+                await events[trigger_name].wait()
+                await event_queue.enqueue_event(
+                    TaskArtifactUpdateEvent(
+                        task_id=context.task_id,
+                        context_id=context.context_id,
+                        artifact=Artifact(
+                            artifact_id=artifact_id,
+                            parts=[Part(text=artifact_id)],
+                        ),
+                    )
+                )
+
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(EmitAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=True
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+
+    res = await it.__anext__()
+    task_id = res.task.id if res.HasField('task') else res.status_update.task_id
+
+    async def monitor_artifacts():
+        try:
+            async for event in client.subscribe(
+                SubscribeToTaskRequest(id=task_id)
+            ):
+                if event.HasField('artifact_update'):
+                    artifact_id = event.artifact_update.artifact.artifact_id
+                    if artifact_id.startswith('artifact_'):
+                        phase_num = artifact_id.split('_')[1]
+                        events[f'emitted_phase_{phase_num}'].set()
+        except asyncio.CancelledError:
+            pass
+
+    monitor_task = asyncio.create_task(monitor_artifacts())
+
+    async def subscribe_and_collect(artifacts_to_collect: int | None = None):
+        ready_event = asyncio.Event()
+
+        async def collect():
+            collected = []
+            artifacts_seen = 0
+            try:
+                async for event in client.subscribe(
+                    SubscribeToTaskRequest(id=task_id)
+                ):
+                    collected.append(event)
+                    ready_event.set()
+                    if event.HasField('artifact_update'):
+                        artifacts_seen += 1
+                        if (
+                            artifacts_to_collect is not None
+                            and artifacts_seen >= artifacts_to_collect
+                        ):
+                            break
+            except asyncio.CancelledError:
+                pass
+            return collected
+
+        task = asyncio.create_task(collect())
+        await ready_event.wait()
+        return task
+
+    sub1_task = await subscribe_and_collect()
+
+    events['trigger_phase_1'].set()
+    await events['emitted_phase_1'].wait()
+
+    sub2_task = await subscribe_and_collect(artifacts_to_collect=1)
+    sub3_task = await subscribe_and_collect(artifacts_to_collect=2)
+
+    events['trigger_phase_2'].set()
+    await events['emitted_phase_2'].wait()
+
+    events['trigger_phase_3'].set()
+    await events['emitted_phase_3'].wait()
+
+    sub4_task = await subscribe_and_collect()
+
+    events['trigger_phase_4'].set()
+    await events['emitted_phase_4'].wait()
+
+    def get_artifact_updates(evs):
+        return [
+            [p.text for p in sr.artifact_update.artifact.parts]
+            for sr in evs
+            if sr.HasField('artifact_update')
+        ]
+
+    assert get_artifact_updates(await sub1_task) == [
+        ['artifact_1'],
+        ['artifact_2'],
+        ['artifact_3'],
+        ['artifact_4'],
+    ]
+
+    assert get_artifact_updates(await sub2_task) == [
+        ['artifact_2'],
+    ]
+    assert get_artifact_updates(await sub3_task) == [
+        ['artifact_2'],
+        ['artifact_3'],
+    ]
+    assert get_artifact_updates(await sub4_task) == [
+        ['artifact_4'],
+    ]
+
+    monitor_task.cancel()
+
+
+# Return message directly.
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+@pytest.mark.parametrize(
+    'return_immediately',
+    [False, True],
+    ids=['no_return_immediately', 'return_immediately'],
+)
+async def test_scenario_publish_message(
+    use_legacy, streaming, return_immediately
+):
+    class MessageAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            await event_queue.enqueue_event(
+                Message(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    message_id='msg-1',
+                    role=Role.ROLE_AGENT,
+                    parts=[Part(text='response text')],
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(MessageAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(
+                return_immediately=return_immediately
+            ),
+        )
+    )
+    events = [event async for event in it]
+
+    (event,) = events
+    assert event.HasField('message')
+    assert event.message.parts[0].text == 'response text'
+
+    tasks = (await client.list_tasks(ListTasksRequest())).tasks
+    assert len(tasks) == 0
+
+
+# Scenario: Publish ArtifactUpdateEvent
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'transport',
+    [TransportProtocol.GRPC, TransportProtocol.HTTP_JSON],
+    ids=['grpc', 'rest'],
+)
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_publish_artifact(
+    use_legacy: bool,
+    streaming: bool,
+    transport: TransportProtocol,
+    rest_setup: RestSetup,
+) -> None:
+    class ArtifactAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            await event_queue.enqueue_event(
+                TaskArtifactUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    artifact=Artifact(
+                        artifact_id='art-1', parts=[Part(text='artifact data')]
+                    ),
+                )
+            )
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ) -> None:
+            pass
+
+    handler = create_handler(ArtifactAgent(), use_legacy)
+    client = await create_client(
+        handler,
+        agent_card=agent_card(),
+        streaming=streaming,
+        transport=transport,
+        rest_setup=rest_setup,
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    events = [event async for event in it]
+
+    if streaming:
+        last_event = events[-1]
+        assert get_state(last_event) == TaskState.TASK_STATE_COMPLETED
+
+        artifact_events = [e for e in events if e.HasField('artifact_update')]
+        assert len(artifact_events) > 0, (
+            'Bug: Streaming should return the artifact update event'
+        )
+        assert (
+            artifact_events[0].artifact_update.artifact.artifact_id == 'art-1'
+        )
+    else:
+        last_event = events[-1]
+        assert last_event.HasField('task')
+        assert last_event.task.status.state == TaskState.TASK_STATE_COMPLETED
+
+        assert len(last_event.task.artifacts) > 0, (
+            'Bug: Task should include the published artifact'
+        )
+        assert last_event.task.artifacts[0].artifact_id == 'art-1'
+
+
+# Scenario: Enqueue Task twice
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_enqueue_task_twice(caplog, use_legacy, streaming):
+    class DoubleTaskAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task1 = Task(
+                id=context.task_id,
+                context_id=context.context_id,
+                status=TaskStatus(
+                    state=TaskState.TASK_STATE_WORKING,
+                    message=Message(parts=[Part(text='First task')]),
+                ),
+            )
+            await event_queue.enqueue_event(task1)
+
+            # This is undefined behavior, but it should not crash or hang.
+            task2 = Task(
+                id=context.task_id,
+                context_id=context.context_id,
+                status=TaskStatus(
+                    state=TaskState.TASK_STATE_WORKING,
+                    message=Message(parts=[Part(text='Second task')]),
+                ),
+            )
+            await event_queue.enqueue_event(task2)
+
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(DoubleTaskAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    _ = [event async for event in it]
+
+    (final_task,) = (await client.list_tasks(ListTasksRequest())).tasks
+
+    if use_legacy:
+        assert [part.text for part in final_task.history[0].parts] == [
+            'Second task'
+        ]
+    else:
+        assert [part.text for part in final_task.history[0].parts] == [
+            'First task'
+        ]
+
+        # Validate that new version logs with error exactly once 'Ignoring task replacement'
+        error_logs = [
+            record.message
+            for record in caplog.records
+            if record.levelname == 'ERROR'
+            and 'Ignoring task replacement' in record.message
+        ]
+
+        assert len(error_logs) == 1
+
+
+# Scenario: Task restoration - terminal state
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+@pytest.mark.parametrize(
+    'subscribe_first',
+    [False, True],
+    ids=['no_subscribe_first', 'subscribe_first'],
+)
+async def test_restore_task_terminal_state(
+    use_legacy, streaming, subscribe_first
+):
+    class TerminalAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_COMPLETED
+            await event_queue.enqueue_event(task)
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    task_store = InMemoryTaskStore()
+    handler1 = create_handler(
+        TerminalAgent(), use_legacy, task_store=task_store
+    )
+    client1 = await create_client(
+        handler1, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg-1', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+    it1 = client1.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    events1 = [event async for event in it1]
+    task_id = get_task_id(events1[-1])
+
+    await wait_for_state(
+        client1, task_id, expected_states={TaskState.TASK_STATE_COMPLETED}
+    )
+
+    # Restore task in a new handler (simulating server restart)
+    handler2 = create_handler(
+        TerminalAgent(), use_legacy, task_store=task_store
+    )
+    client2 = await create_client(
+        handler2, agent_card=agent_card(), streaming=streaming
+    )
+
+    restored_task = await client2.get_task(GetTaskRequest(id=task_id))
+    assert restored_task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    if subscribe_first and streaming:
+        with pytest.raises(
+            Exception,
+            match=r'terminal state: TASK_STATE_COMPLETED',
+        ):
+            async for _ in client2.subscribe(
+                SubscribeToTaskRequest(id=task_id)
+            ):
+                pass
+
+    msg2 = Message(
+        task_id=task_id,
+        message_id='test-msg-2',
+        role=Role.ROLE_USER,
+        parts=[Part(text='message to completed task')],
+    )
+
+    with pytest.raises(
+        Exception, match=r'terminal state: TASK_STATE_COMPLETED'
+    ):
+        async for _ in client2.send_message(SendMessageRequest(message=msg2)):
+            pass
+
+    if streaming:
+        with pytest.raises(
+            Exception,
+            match=r'terminal state: TASK_STATE_COMPLETED',
+        ):
+            async for _ in client2.subscribe(
+                SubscribeToTaskRequest(id=task_id)
+            ):
+                pass
+
+
+# Scenario: Task restoration - user input required state
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+@pytest.mark.parametrize(
+    'subscribe_mode',
+    ['none', 'drop', 'listen'],
+    ids=['no_sub', 'sub_drop', 'sub_listen'],
+)
+async def test_restore_task_input_required_state(
+    use_legacy, streaming, subscribe_mode
+):
+    task_store = InMemoryTaskStore()
+    handler1 = create_handler(
+        InputRequiredAgent(), use_legacy, task_store=task_store
+    )
+    client1 = await create_client(
+        handler1, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg1 = Message(
+        message_id='test-msg-1', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+    it1 = client1.send_message(
+        SendMessageRequest(
+            message=msg1,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    events1 = [event async for event in it1]
+
+    task_id = get_task_id(events1[-1])
+    context_id = get_task_context_id(events1[-1])
+
+    await wait_for_state(
+        client1, task_id, expected_states={TaskState.TASK_STATE_INPUT_REQUIRED}
+    )
+
+    # Restore task in a new handler (simulating server restart)
+    handler2 = create_handler(
+        InputRequiredAgent(), use_legacy, task_store=task_store
+    )
+    client2 = await create_client(
+        handler2, agent_card=agent_card(), streaming=streaming
+    )
+
+    restored_task = await client2.get_task(GetTaskRequest(id=task_id))
+    assert restored_task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    # Subscription logic based on mode
+    listen_task = None
+    if streaming:
+        if subscribe_mode == 'drop':
+            # Subscribing and dropping immediately (cancelling the generator)
+            async for _ in client2.subscribe(
+                SubscribeToTaskRequest(id=task_id)
+            ):
+                break
+        elif subscribe_mode == 'listen':
+            sub_started_event = asyncio.Event()
+
+            async def listen_to_end():
+                res = []
+                async for ev in client2.subscribe(
+                    SubscribeToTaskRequest(id=task_id)
+                ):
+                    res.append(ev)
+                    sub_started_event.set()
+                return res
+
+            listen_task = asyncio.create_task(listen_to_end())
+            # Wait for subscription to establish and yield the initial task event
+            await asyncio.wait_for(sub_started_event.wait(), timeout=1.0)
+
+    msg2 = Message(
+        task_id=task_id,
+        context_id=context_id,
+        message_id='test-msg-2',
+        role=Role.ROLE_USER,
+        parts=[Part(text='input')],
+    )
+
+    it2 = client2.send_message(
+        SendMessageRequest(
+            message=msg2,
+            configuration=SendMessageConfiguration(return_immediately=False),
+        )
+    )
+    events2 = [event async for event in it2]
+
+    if streaming:
+        assert (
+            events2[-1].status_update.status.state
+            == TaskState.TASK_STATE_COMPLETED
+        )
+    else:
+        assert events2[-1].task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    if listen_task:
+        if use_legacy and streaming:
+            # Error: Legacy handler does not properly manage subscriptions for restored tasks
+            with pytest.raises(TaskNotFoundError):
+                await listen_task
+        else:
+            listen_events = await listen_task
+            # The first event is the initial task state (INPUT_REQUIRED), the last should be COMPLETED
+            assert (
+                get_state(listen_events[-1]) == TaskState.TASK_STATE_COMPLETED
+            )
+
+    final_task = await client2.get_task(GetTaskRequest(id=task_id))
+    assert final_task.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+# Scenario 20: Create initial task with new_task
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+@pytest.mark.parametrize('initial_task_type', ['new_task', 'status_update'])
+async def test_scenario_initial_task_types(
+    request, use_legacy, streaming, initial_task_type
+):
+    if use_legacy and streaming and initial_task_type == 'new_task':
+        # There is a race condition which manifests itself in flaky CI failures.
+        # Given that we don't use legacy by default anymore, xfail it.
+        # Flakiness rate is around 1 failure per 30 runs, so use strict=False
+        # to avoid failing on a passing xfail.
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason='https://github.com/a2aproject/a2a-python/issues/869',
+                strict=False,
+                raises=ValueError,
+            )
+        )
+
+    started_event = asyncio.Event()
+    continue_event = asyncio.Event()
+
+    class InitialTaskAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            if initial_task_type == 'new_task':
+                # Create with new_task
+                task = new_task_from_user_message(context.message)
+                task.status.state = TaskState.TASK_STATE_WORKING
+                await event_queue.enqueue_event(task)
+            else:
+                # Create with status update (illegal in v2)
+                await event_queue.enqueue_event(
+                    TaskStatusUpdateEvent(
+                        task_id=context.task_id,
+                        context_id=context.context_id,
+                        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+                    )
+                )
+
+            started_event.set()
+            await continue_event.wait()
+
+            await event_queue.enqueue_event(
+                TaskArtifactUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    artifact=Artifact(
+                        artifact_id='art-1', parts=[Part(text='artifact data')]
+                    ),
+                )
+            )
+
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=context.task_id,
+                    context_id=context.context_id,
+                    status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+                )
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(InitialTaskAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(
+        SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(
+                return_immediately=streaming
+            ),
+        )
+    )
+
+    if streaming:
+        if initial_task_type == 'status_update' and not use_legacy:
+            with pytest.raises(
+                InvalidAgentResponseError,
+                match='Agent should enqueue Task before TaskStatusUpdateEvent event',
+            ):
+                await it.__anext__()
+
+            # End of the test.
+            return
+
+        res = await it.__anext__()
+        if initial_task_type == 'status_update' and use_legacy:
+            # First message has to be a Task.
+            assert res.HasField('status_update')
+
+            # End of the test.
+            return
+
+        assert res.HasField('task')
+        task_id = get_task_id(res)
+
+        await asyncio.wait_for(started_event.wait(), timeout=1.0)
+
+        # Start subscription
+        sub = client.subscribe(SubscribeToTaskRequest(id=task_id))
+
+        # first subscriber receives current task state (WORKING)
+        first_event = await sub.__anext__()
+        assert first_event.HasField('task')
+
+        continue_event.set()
+
+        events = [first_event] + [event async for event in sub]
+    else:
+        # blocking
+        async def release_agent():
+            await started_event.wait()
+            continue_event.set()
+
+        release_task = asyncio.create_task(release_agent())
+        if initial_task_type == 'status_update' and not use_legacy:
+            with pytest.raises(
+                InvalidAgentResponseError,
+                match='Agent should enqueue Task before TaskStatusUpdateEvent event',
+            ):
+                events = [event async for event in it]
+            # End of the test
+            return
+        else:
+            events = [event async for event in it]
+        await release_task
+
+    if streaming:
+        task = events[0]
+        assert task.HasField('task')
+        validate_state(task, TaskState.TASK_STATE_WORKING)
+
+        artifact_updates = [
+            event for event in events if event.HasField('artifact_update')
+        ]
+        assert len(artifact_updates) == 1
+        assert (
+            artifact_updates[0].artifact_update.artifact.artifact_id == 'art-1'
+        )
+
+        status_updates = [
+            event for event in events if event.HasField('status_update')
+        ]
+        if use_legacy:
+            # Legacy streaming can race with queue shutdown and occasionally
+            # miss the final status update, while still persisting the terminal
+            # task state.
+            if status_updates:
+                validate_state(
+                    status_updates[-1], TaskState.TASK_STATE_COMPLETED
+                )
+        else:
+            assert len(status_updates) == 1
+            validate_state(status_updates[0], TaskState.TASK_STATE_COMPLETED)
+    else:
+        (task,) = events
+        assert task.HasField('task')
+        validate_state(task, TaskState.TASK_STATE_COMPLETED)
+        (artifact,) = task.task.artifacts
+        assert artifact.artifact_id == 'art-1'
+        task_id = task.task.id
+
+    (final_task_from_list,) = (
+        await client.list_tasks(ListTasksRequest(include_artifacts=True))
+    ).tasks
+    assert len(final_task_from_list.artifacts) > 0
+    assert final_task_from_list.artifacts[0].artifact_id == 'art-1'
+
+    final_task = await client.get_task(GetTaskRequest(id=task_id))
+    assert final_task.status.state == TaskState.TASK_STATE_COMPLETED
+    assert len(final_task.artifacts) > 0
+    assert final_task.artifacts[0].artifact_id == 'art-1'
+
+
+# Scenario 23: Invalid Agent Response - Task followed by Message
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_23_invalid_response_task_message(use_legacy, streaming):
+    class TaskMessageAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+            await event_queue.enqueue_event(
+                Message(message_id='m1', parts=[Part(text='m1')])
+            )
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(TaskMessageAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    msg = Message(
+        message_id='test-msg', role=Role.ROLE_USER, parts=[Part(text='start')]
+    )
+
+    it = client.send_message(SendMessageRequest(message=msg))
+
+    if use_legacy:
+        # Legacy: no error.
+        async for _ in it:
+            pass
+    else:
+        with pytest.raises(
+            InvalidAgentResponseError,
+            match='Received Message object in task mode',
+        ):
+            async for _ in it:
+                pass
+
+
+# Scenario: Task context_id and task_id visibility
+@pytest.mark.timeout(2.0)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_legacy', [False, True], ids=['v2', 'legacy'])
+@pytest.mark.parametrize(
+    'streaming', [False, True], ids=['blocking', 'streaming']
+)
+async def test_scenario_context_id_visibility(use_legacy, streaming):
+    seen_contexts = []
+
+    class ContextIdAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            seen_contexts.append((context.task_id, context.context_id))
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_COMPLETED
+            await event_queue.enqueue_event(task)
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    handler = create_handler(ContextIdAgent(), use_legacy)
+    client = await create_client(
+        handler, agent_card=agent_card(), streaming=streaming
+    )
+
+    # 1. Create a new task (empty context_id, empty task_id)
+    msg1 = Message(
+        message_id='test-msg-1',
+        role=Role.ROLE_USER,
+        parts=[Part(text='start task 1')],
+    )
+    it1 = client.send_message(SendMessageRequest(message=msg1))
+    events1 = [event async for event in it1]
+
+    agent_task1_id, agent_context1_id = seen_contexts[0]
+    client_task1_id = get_task_id(events1[-1])
+    client_context1_id = get_task_context_id(events1[-1])
+
+    # Verify that agent can see non-empty context_id and task_id
+    assert agent_task1_id != ''
+    assert agent_context1_id != ''
+
+    # Verify for task1 that context_id and task_id visible by agent and client are the same.
+    assert agent_task1_id == client_task1_id
+    assert agent_context1_id == client_context1_id
+
+    # 2. Create a new task with context_id from task_1: task_2
+    msg2 = Message(
+        message_id='test-msg-2',
+        context_id=client_context1_id,
+        role=Role.ROLE_USER,
+        parts=[Part(text='start task 2')],
+    )
+    it2 = client.send_message(SendMessageRequest(message=msg2))
+    events2 = [event async for event in it2]
+
+    agent_task2_id, agent_context2_id = seen_contexts[1]
+    client_task2_id = get_task_id(events2[-1])
+    client_context2_id = get_task_context_id(events2[-1])
+
+    # Verify for task2 that context_id and task_id visible by agent and client are the same.
+    assert agent_task2_id == client_task2_id
+    assert agent_context2_id == client_context2_id
+
+    # Verify that agent can see context_id the same as in task_1 and different task id
+    assert agent_context2_id == agent_context1_id
+    assert agent_task2_id != agent_task1_id
+
+
+# Cancel-terminal-state (issue #1170): cancel must leave the task in a state a
+# caller can act on. These two scenarios are @technicalpickles' repro from
+# https://github.com/a2aproject/a2a-python/pull/1171, folded in here verbatim
+# with the strict-xfail markers dropped since this PR fixes what they pin. Both
+# executors below define cancel() as an empty teardown, which is what
+# InputRequiredAgent, SlowAgent and DummyAgentExecutor use in this file and what
+# a real cleanup-only executor looks like.
+
+
+async def _start_task(client, text):
+    it = client.send_message(
+        SendMessageRequest(
+            message=Message(
+                message_id='test-msg',
+                role=Role.ROLE_USER,
+                parts=[Part(text=text)],
+            ),
+            configuration=SendMessageConfiguration(return_immediately=True),
+        )
+    )
+    res = await it.__anext__()
+    return res.task.id if res.HasField('task') else res.status_update.task_id
+
+
+@pytest.mark.timeout(5.0)
+@pytest.mark.asyncio
+async def test_scenario_19_mid_run_cancel_reaches_a_terminal_state():
+    """A caller who cancels should at least be able to stop polling."""
+    started = asyncio.Event()
+    hang = asyncio.Event()
+
+    class SilentCancelAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_WORKING
+            await event_queue.enqueue_event(task)
+            started.set()
+            await hang.wait()
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    client = await create_client(
+        create_handler(SilentCancelAgent(), use_legacy=False),
+        agent_card=agent_card(),
+        streaming=True,
+    )
+    task_id = await _start_task(client, 'hello')
+    await asyncio.wait_for(started.wait(), timeout=1.0)
+
+    await client.cancel_task(CancelTaskRequest(id=task_id))
+    task_after = await client.get_task(GetTaskRequest(id=task_id))
+
+    assert task_after.status.state in TERMINAL_TASK_STATES
+
+
+@pytest.mark.timeout(5.0)
+@pytest.mark.asyncio
+async def test_scenario_19_cancel_of_parked_task_does_not_silently_succeed():
+    """input-required is non-terminal, so cancel should either work or raise
+    TaskNotCancelableError. Reporting success and changing nothing is the one
+    outcome a caller cannot act on."""
+
+    class ParkingAgent(AgentExecutor):
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            task = new_task_from_user_message(context.message)
+            task.status.state = TaskState.TASK_STATE_INPUT_REQUIRED
+            await event_queue.enqueue_event(task)
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            pass
+
+    client = await create_client(
+        create_handler(ParkingAgent(), use_legacy=False),
+        agent_card=agent_card(),
+        streaming=True,
+    )
+    task_id = await _start_task(client, 'start')
+
+    for _ in range(50):
+        parked = await client.get_task(GetTaskRequest(id=task_id))
+        if parked.status.state == TaskState.TASK_STATE_INPUT_REQUIRED:
+            break
+        await asyncio.sleep(0.02)
+    assert parked.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    result = await client.cancel_task(CancelTaskRequest(id=task_id))
+
+    assert result.status.state != TaskState.TASK_STATE_INPUT_REQUIRED
diff --git a/tests/integration/test_stream_generator_cleanup.py b/tests/integration/test_stream_generator_cleanup.py
new file mode 100644
index 000000000..3d9b1b171
--- /dev/null
+++ b/tests/integration/test_stream_generator_cleanup.py
@@ -0,0 +1,133 @@
+"""Test that streaming SSE responses clean up without athrow() errors.
+
+Reproduces https://github.com/a2aproject/a2a-python/issues/911 —
+``RuntimeError: athrow(): asynchronous generator is already running``
+during event-loop shutdown after consuming a streaming response.
+"""
+
+import asyncio
+import gc
+
+from typing import Any
+from uuid import uuid4
+
+import httpx
+import pytest
+
+from a2a.client.base_client import BaseClient
+from a2a.client.client import ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+)
+from a2a.utils import TransportProtocol
+from starlette.applications import Starlette
+
+
+class _MessageExecutor(AgentExecutor):
+    """Responds with a single Message event."""
+
+    async def execute(self, ctx: RequestContext, eq: EventQueue) -> None:
+        await eq.enqueue_event(
+            Message(
+                role=Role.ROLE_AGENT,
+                message_id=str(uuid4()),
+                parts=[Part(text='Hello')],
+                context_id=ctx.context_id,
+                task_id=ctx.task_id,
+            )
+        )
+
+    async def cancel(self, ctx: RequestContext, eq: EventQueue) -> None:
+        pass
+
+
+@pytest.fixture
+def client():
+    """Creates a JSON-RPC client backed by an in-process ASGI server."""
+    card = AgentCard(
+        name='T',
+        description='T',
+        version='1',
+        capabilities=AgentCapabilities(streaming=True),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        supported_interfaces=[
+            AgentInterface(
+                protocol_binding=TransportProtocol.JSONRPC,
+                url='http://test',
+            ),
+        ],
+    )
+    handler = DefaultRequestHandler(
+        agent_executor=_MessageExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=card,
+        queue_manager=InMemoryQueueManager(),
+    )
+    app = Starlette(
+        routes=[
+            *create_agent_card_routes(agent_card=card, card_url='/card'),
+            *create_jsonrpc_routes(
+                request_handler=handler,
+                rpc_url='/',
+            ),
+        ]
+    )
+    return ClientFactory(
+        config=ClientConfig(
+            httpx_client=httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=app),
+                base_url='http://test',
+            )
+        )
+    ).create(card)
+
+
+@pytest.mark.asyncio
+async def test_stream_message_no_athrow(client: BaseClient) -> None:
+    """Consuming a streamed Message must not leave broken async generators."""
+    errors: list[dict[str, Any]] = []
+    loop = asyncio.get_event_loop()
+    orig = loop.get_exception_handler()
+    loop.set_exception_handler(lambda _l, ctx: errors.append(ctx))
+
+    try:
+        msg = Message(
+            role=Role.ROLE_USER,
+            message_id=f'msg-{uuid4()}',
+            parts=[Part(text='hi')],
+        )
+        events = [
+            e
+            async for e in client.send_message(
+                request=SendMessageRequest(message=msg)
+            )
+        ]
+        assert events
+        assert events[0].HasField('message')
+
+        gc.collect()
+        await loop.shutdown_asyncgens()
+
+        bad = [
+            e
+            for e in errors
+            if 'asynchronous generator' in str(e.get('message', ''))
+        ]
+        assert not bad, '\n'.join(str(e.get('message', '')) for e in bad)
+    finally:
+        loop.set_exception_handler(orig)
+        await client.close()
diff --git a/tests/integration/test_tenant.py b/tests/integration/test_tenant.py
new file mode 100644
index 000000000..64038f1e9
--- /dev/null
+++ b/tests/integration/test_tenant.py
@@ -0,0 +1,251 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from a2a.client import ClientConfig, ClientFactory
+from a2a.client.transports.tenant_decorator import TenantTransportDecorator
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    SendMessageRequest,
+    Task,
+)
+from a2a.utils.constants import TransportProtocol
+from httpx import ASGITransport, AsyncClient
+from starlette.applications import Starlette
+
+
+class TestTenantDecorator:
+    @pytest.fixture
+    def agent_card(self):
+        return AgentCard(
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://example.com/rest',
+                    protocol_binding=TransportProtocol.HTTP_JSON,
+                    tenant='tenant-1',
+                ),
+                AgentInterface(
+                    url='http://example.com/jsonrpc',
+                    protocol_binding=TransportProtocol.JSONRPC,
+                    tenant='tenant-2',
+                ),
+                AgentInterface(
+                    url='http://example.com/grpc',
+                    protocol_binding=TransportProtocol.GRPC,
+                    tenant='tenant-3',
+                ),
+            ],
+            capabilities=AgentCapabilities(streaming=True),
+        )
+
+    @pytest.mark.asyncio
+    async def test_tenant_decorator_rest(self, agent_card):
+        mock_httpx = AsyncMock(spec=httpx.AsyncClient)
+        mock_httpx.is_closed = False
+        mock_httpx.build_request.return_value = MagicMock()
+        mock_httpx.send.return_value = MagicMock(
+            status_code=200, json=lambda: {'message': {}}
+        )
+
+        config = ClientConfig(
+            httpx_client=mock_httpx,
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+        factory = ClientFactory(config)
+        client = factory.create(agent_card)
+
+        assert isinstance(client._transport, TenantTransportDecorator)
+        assert client._transport._tenant == 'tenant-1'
+
+        # Test SendMessage (POST) - Use transport directly to avoid streaming complexity in mock
+        request = SendMessageRequest(message=Message(parts=[{'text': 'hi'}]))
+        await client._transport.send_message(request)
+
+        # Check that tenant was populated in request
+        assert request.tenant == 'tenant-1'
+
+        # Check that path was prepended in the underlying transport
+        mock_httpx.build_request.assert_called()
+        send_call = next(
+            c
+            for c in mock_httpx.build_request.call_args_list
+            if 'message:send' in c.args[1]
+        )
+        args, kwargs = send_call
+        assert args[1] == 'http://example.com/rest/tenant-1/message:send'
+        assert 'tenant' in kwargs['json']
+
+    @pytest.mark.asyncio
+    async def test_tenant_decorator_jsonrpc(self, agent_card):
+        mock_httpx = AsyncMock(spec=httpx.AsyncClient)
+        mock_httpx.is_closed = False
+        mock_httpx.build_request.return_value = MagicMock()
+        mock_httpx.send.return_value = MagicMock(
+            status_code=200,
+            json=lambda: {
+                'result': {'message': {}},
+                'id': '1',
+                'jsonrpc': '2.0',
+            },
+        )
+
+        config = ClientConfig(
+            httpx_client=mock_httpx,
+            supported_protocol_bindings=[TransportProtocol.JSONRPC],
+        )
+        factory = ClientFactory(config)
+        client = factory.create(agent_card)
+
+        assert isinstance(client._transport, TenantTransportDecorator)
+        assert client._transport._tenant == 'tenant-2'
+
+        request = SendMessageRequest(message=Message(parts=[{'text': 'hi'}]))
+        await client._transport.send_message(request)
+
+        mock_httpx.build_request.assert_called()
+        _, kwargs = mock_httpx.build_request.call_args
+        assert kwargs['json']['params']['tenant'] == 'tenant-2'
+
+    @pytest.mark.asyncio
+    async def test_tenant_decorator_grpc(self, agent_card):
+        mock_channel = MagicMock()
+        config = ClientConfig(
+            grpc_channel_factory=lambda url: mock_channel,
+            supported_protocol_bindings=[TransportProtocol.GRPC],
+        )
+
+        with patch('a2a.types.a2a_pb2_grpc.A2AServiceStub') as mock_stub_class:
+            mock_stub = mock_stub_class.return_value
+            mock_stub.SendMessage = AsyncMock(return_value={'message': {}})
+
+            factory = ClientFactory(config)
+            client = factory.create(agent_card)
+
+            assert isinstance(client._transport, TenantTransportDecorator)
+            assert client._transport._tenant == 'tenant-3'
+
+            await client._transport.send_message(
+                SendMessageRequest(message=Message(parts=[{'text': 'hi'}]))
+            )
+
+            call_args = mock_stub.SendMessage.call_args
+            assert call_args[0][0].tenant == 'tenant-3'
+
+    @pytest.mark.asyncio
+    async def test_tenant_decorator_explicit_override(self, agent_card):
+        mock_httpx = AsyncMock(spec=httpx.AsyncClient)
+        mock_httpx.is_closed = False
+        mock_httpx.build_request.return_value = MagicMock()
+        mock_httpx.send.return_value = MagicMock(
+            status_code=200, json=lambda: {'message': {}}
+        )
+
+        config = ClientConfig(
+            httpx_client=mock_httpx,
+            supported_protocol_bindings=[TransportProtocol.HTTP_JSON],
+        )
+        factory = ClientFactory(config)
+        client = factory.create(agent_card)
+
+        request = SendMessageRequest(
+            message=Message(parts=[{'text': 'hi'}]), tenant='explicit-tenant'
+        )
+        await client._transport.send_message(request)
+
+        assert request.tenant == 'explicit-tenant'
+
+        send_call = next(
+            c
+            for c in mock_httpx.build_request.call_args_list
+            if 'message:send' in c.args[1]
+        )
+        args, _ = send_call
+        assert args[1] == 'http://example.com/rest/explicit-tenant/message:send'
+
+
+class TestJSONRPCTenantIntegration:
+    @pytest.fixture
+    def mock_handler(self):
+        handler = AsyncMock(spec=RequestHandler)
+        handler.on_list_tasks.return_value = ListTasksResponse(
+            tasks=[Task(id='task-1')]
+        )
+        return handler
+
+    @pytest.fixture
+    def jsonrpc_agent_card(self):
+        return AgentCard(
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://testserver/jsonrpc',
+                    protocol_binding=TransportProtocol.JSONRPC,
+                    tenant='my-test-tenant',
+                ),
+            ],
+            capabilities=AgentCapabilities(
+                streaming=False,
+                push_notifications=False,
+            ),
+        )
+
+    @pytest.fixture
+    def server_app(self, jsonrpc_agent_card, mock_handler):
+        agent_card_routes = create_agent_card_routes(
+            agent_card=jsonrpc_agent_card, card_url='/'
+        )
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=mock_handler,
+            rpc_url='/jsonrpc',
+        )
+        app = Starlette(routes=[*agent_card_routes, *jsonrpc_routes])
+        return app
+
+    @pytest.mark.asyncio
+    async def test_jsonrpc_tenant_context_population(
+        self, server_app, mock_handler, jsonrpc_agent_card
+    ):
+        """
+        Integration test to verify that a tenant configured in the client
+        is correctly propagated to the ServerCallContext in the server
+        via the JSON-RPC transport.
+        """
+        # 1. Setup the client using the server app as the transport
+        # We use ASGITransport so httpx calls go directly to the Starlette app
+        transport = ASGITransport(app=server_app)
+        async with AsyncClient(
+            transport=transport, base_url='http://testserver'
+        ) as httpx_client:
+            # Create the A2A client properly configured
+            config = ClientConfig(
+                httpx_client=httpx_client,
+                supported_protocol_bindings=[TransportProtocol.JSONRPC],
+            )
+            factory = ClientFactory(config)
+            client = factory.create(jsonrpc_agent_card)
+
+            # 2. Make the call (list_tasks)
+            response = await client.list_tasks(ListTasksRequest())
+
+            # 3. Verify response
+            assert len(response.tasks) == 1
+            assert response.tasks[0].id == 'task-1'
+
+            # 4. Verify ServerCallContext on the server side
+            mock_handler.on_list_tasks.assert_called_once()
+            call_args = mock_handler.on_list_tasks.call_args
+
+            # call_args[0] are positional args: (request, context)
+            # Check call_args signature in jsonrpc_handler.py: await self.handler.list_tasks(request_obj, context)
+
+            server_context = call_args[0][1]
+            assert isinstance(server_context, ServerCallContext)
+            assert server_context.tenant == 'my-test-tenant'
diff --git a/tests/integration/test_version_header.py b/tests/integration/test_version_header.py
new file mode 100644
index 000000000..1e6367097
--- /dev/null
+++ b/tests/integration/test_version_header.py
@@ -0,0 +1,204 @@
+import pytest
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.types.a2a_pb2 import AgentCapabilities, AgentCard, Task
+from a2a.utils.constants import VERSION_HEADER
+from fastapi import FastAPI
+from starlette.testclient import TestClient
+
+
+class DummyAgentExecutor(AgentExecutor):
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.fixture
+def test_app():
+    agent_card = AgentCard(
+        name='Test Agent',
+        version='1.0.0',
+        capabilities=AgentCapabilities(streaming=True),
+    )
+    handler = DefaultRequestHandler(
+        agent_executor=DummyAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=agent_card,
+        queue_manager=InMemoryQueueManager(),
+        push_config_store=InMemoryPushNotificationConfigStore(),
+    )
+
+    async def mock_on_message_send(*args, **kwargs):
+        task = Task(id='task-123')
+        task.status.message.message_id = 'msg-123'
+        return task
+
+    async def mock_on_message_send_stream(*args, **kwargs):
+        task = Task(id='task-123')
+        task.status.message.message_id = 'msg-123'
+        yield task
+
+    handler.on_message_send = mock_on_message_send
+    handler.on_message_send_stream = mock_on_message_send_stream
+
+    app = FastAPI()
+    agent_card_routes = create_agent_card_routes(
+        agent_card=agent_card, card_url='/'
+    )
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=handler, rpc_url='/jsonrpc', enable_v0_3_compat=True
+    )
+    app.routes.extend(agent_card_routes)
+    app.routes.extend(jsonrpc_routes)
+
+    rest_routes = create_rest_routes(
+        request_handler=handler, path_prefix='/rest', enable_v0_3_compat=True
+    )
+    app.routes.extend(rest_routes)
+    return app
+
+
+@pytest.fixture
+def client(test_app):
+    return TestClient(test_app, raise_server_exceptions=False)
+
+
+@pytest.mark.parametrize('transport', ['rest', 'jsonrpc'])
+@pytest.mark.parametrize('endpoint_ver', ['0.3', '1.0'])
+@pytest.mark.parametrize('is_streaming', [False, True])
+@pytest.mark.parametrize(
+    'header_val, should_succeed',
+    [
+        (None, '0.3'),
+        ('0.3', '0.3'),
+        ('1.0', '1.0'),
+        ('1.2', '1.0'),
+        ('2', 'none'),
+        ('INVALID', 'none'),
+    ],
+)
+def test_version_header_integration(
+    client, transport, endpoint_ver, is_streaming, header_val, should_succeed
+):
+    headers = {}
+    if header_val is not None:
+        headers[VERSION_HEADER] = header_val
+
+    expect_success = endpoint_ver == should_succeed
+
+    if transport == 'rest':
+        if endpoint_ver == '0.3':
+            url = (
+                '/rest/v1/message:stream'
+                if is_streaming
+                else '/rest/v1/message:send'
+            )
+        else:
+            url = (
+                '/rest/message:stream' if is_streaming else '/rest/message:send'
+            )
+
+        payload = {
+            'message': {
+                'messageId': 'msg1',
+                'role': 'ROLE_USER' if endpoint_ver == '1.0' else 'user',
+                'parts': [{'text': 'hello'}] if endpoint_ver == '1.0' else None,
+                'content': [{'text': 'hello'}]
+                if endpoint_ver == '0.3'
+                else None,
+            }
+        }
+        if endpoint_ver == '0.3':
+            del payload['message']['parts']
+        else:
+            del payload['message']['content']
+
+        if is_streaming:
+            headers['Accept'] = 'text/event-stream'
+            with client.stream(
+                'POST', url, json=payload, headers=headers
+            ) as response:
+                response.read()
+
+                if expect_success:
+                    assert response.status_code == 200, response.text
+                else:
+                    assert response.status_code == 400, response.text
+        else:
+            response = client.post(url, json=payload, headers=headers)
+            if expect_success:
+                assert response.status_code == 200, response.text
+            else:
+                assert response.status_code == 400, response.text
+
+    else:
+        url = '/jsonrpc'
+        if endpoint_ver == '0.3':
+            payload = {
+                'jsonrpc': '2.0',
+                'id': '1',
+                'method': 'message/stream' if is_streaming else 'message/send',
+                'params': {
+                    'message': {
+                        'messageId': 'msg1',
+                        'role': 'user',
+                        'parts': [{'text': 'hello'}],
+                    }
+                },
+            }
+        else:
+            payload = {
+                'jsonrpc': '2.0',
+                'id': '1',
+                'method': 'SendStreamingMessage'
+                if is_streaming
+                else 'SendMessage',
+                'params': {
+                    'message': {
+                        'messageId': 'msg1',
+                        'role': 'ROLE_USER',
+                        'parts': [{'text': 'hello'}],
+                    }
+                },
+            }
+
+        if is_streaming:
+            headers['Accept'] = 'text/event-stream'
+            with client.stream(
+                'POST', url, json=payload, headers=headers
+            ) as response:
+                response.read()
+
+                if expect_success:
+                    assert response.status_code == 200, response.text
+                    assert (
+                        'result' in response.text or 'task' in response.text
+                    ), response.text
+                else:
+                    assert response.status_code == 200
+                    assert 'error' in response.text.lower(), response.text
+        else:
+            response = client.post(url, json=payload, headers=headers)
+            assert response.status_code == 200, response.text
+            resp_data = response.json()
+            if expect_success:
+                assert 'result' in resp_data, resp_data
+            else:
+                assert 'error' in resp_data, resp_data
+                expected_code = -32603 if endpoint_ver == '0.3' else -32009
+                assert resp_data['error']['code'] == expected_code
diff --git a/tests/migrations/test_a2a_db_cli.py b/tests/migrations/test_a2a_db_cli.py
new file mode 100644
index 000000000..7b077859d
--- /dev/null
+++ b/tests/migrations/test_a2a_db_cli.py
@@ -0,0 +1,144 @@
+import os
+
+from unittest.mock import patch
+
+import pytest
+
+from a2a.a2a_db_cli import run_migrations
+
+
+@pytest.fixture
+def mock_alembic_command():
+    with (
+        patch('alembic.command.upgrade') as mock_upgrade,
+        patch('alembic.command.downgrade') as mock_downgrade,
+    ):
+        yield mock_upgrade, mock_downgrade
+
+
+@pytest.fixture
+def mock_alembic_config():
+    with patch('a2a.a2a_db_cli.Config') as mock_config:
+        yield mock_config
+
+
+def test_cli_upgrade_offline(mock_alembic_command, mock_alembic_config):
+    mock_upgrade, _ = mock_alembic_command
+    custom_owner = 'test-owner'
+    tasks_table = 'my_tasks'
+    push_table = 'my_push'
+
+    # Simulate: a2a-db upgrade head --sql --add_columns_owner_last_updated-default-ownertest-owner --tasks-table my_tasks --push-notification-configs-table my_push -v
+    test_args = [
+        'a2a-db',
+        'upgrade',
+        'head',
+        '--sql',
+        '--add_columns_owner_last_updated-default-owner',
+        custom_owner,
+        '--tasks-table',
+        tasks_table,
+        '--push-notification-configs-table',
+        push_table,
+        '-v',
+    ]
+    with patch('sys.argv', test_args):
+        with patch.dict(os.environ, {'DATABASE_URL': 'sqlite:///test.db'}):
+            run_migrations()
+
+    # Verify upgrade parameters
+    args, kwargs = mock_upgrade.call_args
+    assert kwargs['sql'] is True
+    assert args[1] == 'head'
+
+    # Verify options were set in config instance
+    # Note: Using assert_any_call because multiple options are set
+    mock_alembic_config.return_value.set_main_option.assert_any_call(
+        'add_columns_owner_last_updated_default_owner', custom_owner
+    )
+    mock_alembic_config.return_value.set_main_option.assert_any_call(
+        'tasks_table', tasks_table
+    )
+    mock_alembic_config.return_value.set_main_option.assert_any_call(
+        'push_notification_configs_table', push_table
+    )
+    mock_alembic_config.return_value.set_main_option.assert_any_call(
+        'verbose', 'true'
+    )
+
+
+def test_cli_downgrade_offline(mock_alembic_command, mock_alembic_config):
+    _, mock_downgrade = mock_alembic_command
+    tasks_table = 'old_tasks'
+
+    # Simulate: a2a-db downgrade base --sql --tasks-table old_tasks
+    test_args = [
+        'a2a-db',
+        'downgrade',
+        'base',
+        '--sql',
+        '--tasks-table',
+        tasks_table,
+    ]
+    with patch('sys.argv', test_args):
+        with patch.dict(os.environ, {'DATABASE_URL': 'sqlite:///test.db'}):
+            run_migrations()
+
+    args, kwargs = mock_downgrade.call_args
+    assert kwargs['sql'] is True
+    assert args[1] == 'base'
+
+    # Verify tables option
+    mock_alembic_config.return_value.set_main_option.assert_any_call(
+        'tasks_table', tasks_table
+    )
+
+
+def test_cli_default_upgrade(mock_alembic_command, mock_alembic_config):
+    mock_upgrade, _ = mock_alembic_command
+
+    # Simulate: a2a-db (no args)
+    test_args = ['a2a-db']
+    with patch('sys.argv', test_args):
+        with patch.dict(os.environ, {'DATABASE_URL': 'sqlite:///test.db'}):
+            run_migrations()
+
+    # Should default to upgrade head
+    mock_upgrade.assert_called_once()
+    args, kwargs = mock_upgrade.call_args
+    assert args[1] == 'head'
+    assert kwargs['sql'] is False
+
+
+def test_cli_database_url_flag(mock_alembic_command, mock_alembic_config):
+    mock_upgrade, _ = mock_alembic_command
+    custom_db = 'sqlite:///custom_cli.db'
+
+    # Simulate: a2a-db --database-url sqlite:///custom_cli.db
+    test_args = ['a2a-db', '--database-url', custom_db]
+    with patch('sys.argv', test_args):
+        with patch.dict(os.environ, {}, clear=True):
+            run_migrations()
+            # Verify the CLI tool set the environment variable
+            assert os.environ['DATABASE_URL'] == custom_db
+
+    mock_upgrade.assert_called()
+
+
+def test_cli_owner_with_downgrade_error(
+    mock_alembic_command, mock_alembic_config
+):
+    # This should trigger parser.error(). Flag --add_columns_owner_last_updated-default-owner is not allowed with downgrade
+    test_args = [
+        'a2a-db',
+        'downgrade',
+        'base',
+        '--add_columns_owner_last_updated-default-owner',
+        'some-owner',
+    ]
+
+    with patch('sys.argv', test_args):
+        with patch.dict(os.environ, {'DATABASE_URL': 'sqlite:///test.db'}):
+            # argparse calls sys.exit on error
+            with pytest.raises(SystemExit):
+                run_migrations()
diff --git a/tests/migrations/test_env.py b/tests/migrations/test_env.py
new file mode 100644
index 000000000..aaf167a22
--- /dev/null
+++ b/tests/migrations/test_env.py
@@ -0,0 +1,138 @@
+import asyncio
+import importlib
+import logging
+import os
+import sys
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+@pytest.fixture
+def mock_alembic_setup():
+    """Fixture to mock alembic context and config for safe import of env.py."""
+    with patch('alembic.context') as mock_context:
+        mock_config = MagicMock()
+        mock_context.config = mock_config
+        # Basic setup to avoid crashes on import
+        mock_config.config_file_name = 'alembic.ini'
+        mock_config.get_section.return_value = {}
+
+        # We need to make sure 'a2a.migrations.env' is not in sys.modules
+        # initially so we can control its execution
+        if 'a2a.migrations.env' in sys.modules:
+            del sys.modules['a2a.migrations.env']
+
+        yield mock_context, mock_config
+
+
+def test_env_py_missing_db_url(mock_alembic_setup):
+    """Test that env.py raises RuntimeError when DATABASE_URL is missing."""
+    mock_context, mock_config = mock_alembic_setup
+
+    with patch.dict(os.environ, {}, clear=True):
+        with pytest.raises(
+            RuntimeError, match='DATABASE_URL environment variable is not set'
+        ):
+            # Using standard import/reload ensures coverage tracking
+            import a2a.migrations.env as env
+
+            importlib.reload(env)
+
+
+def test_env_py_offline_mode(mock_alembic_setup):
+    """Test env.py logic in offline mode."""
+    mock_context, mock_config = mock_alembic_setup
+    db_url = 'sqlite+aiosqlite:///test_cov_offline.db'
+
+    mock_config.config_file_name = None  # Skip fileConfig
+    mock_context.is_offline_mode.return_value = True
+
+    # Mock get_main_option to return db_url for 'sqlalchemy.url'
+    def get_opt(key, default=None):
+        if key == 'sqlalchemy.url':
+            return db_url
+        return default
+
+    mock_config.get_main_option.side_effect = get_opt
+
+    with patch.dict(os.environ, {'DATABASE_URL': db_url}):
+        import a2a.migrations.env as env
+
+        importlib.reload(env)
+
+    # Verify sqlalchemy.url was set from env var
+    mock_config.set_main_option.assert_any_call('sqlalchemy.url', db_url)
+
+    # Verify context.configure was called for offline mode
+    mock_context.configure.assert_called()
+    # Check if url was passed to configure
+    args, kwargs = mock_context.configure.call_args
+    assert kwargs['url'] == db_url
+
+
+@patch('alembic.context.run_migrations')
+@patch('sqlalchemy.ext.asyncio.async_engine_from_config')
+@patch('asyncio.run')
+def test_env_py_online_mode(
+    mock_asyncio_run,
+    mock_async_engine,
+    mock_run_migrations,
+    mock_alembic_setup,
+):
+    """Test env.py logic in online mode."""
+    mock_context, mock_config = mock_alembic_setup
+    db_url = 'sqlite+aiosqlite:///test_cov_online.db'
+
+    mock_config.config_file_name = None
+    mock_context.is_offline_mode.return_value = False
+
+    # Prevent "coroutine never awaited" warning
+    def close_coro(coro):
+        if asyncio.iscoroutine(coro):
+            coro.close()
+
+    mock_asyncio_run.side_effect = close_coro
+
+    with patch.dict(os.environ, {'DATABASE_URL': db_url}):
+        import a2a.migrations.env as env
+
+        importlib.reload(env)
+
+    # Verify sqlalchemy.url was set
+    mock_config.set_main_option.assert_any_call('sqlalchemy.url', db_url)
+
+    # Verify asyncio.run was called to start online migrations
+    mock_asyncio_run.assert_called()
+
+
+def test_env_py_verbose_logging(mock_alembic_setup):
+    """Test that env.py enables verbose logging when 'verbose' option is set."""
+    mock_context, mock_config = mock_alembic_setup
+    db_url = 'sqlite+aiosqlite:///test_cov_verbose.db'
+
+    # Use a real side_effect to simulate config.get_main_option
+    def get_opt(key, default=None):
+        if key == 'verbose':
+            return 'true'
+        if key == 'sqlalchemy.url':
+            return db_url
+        return default
+
+    mock_config.get_main_option.side_effect = get_opt
+    mock_config.config_file_name = None
+    mock_context.is_offline_mode.return_value = True
+
+    with patch('logging.getLogger') as mock_get_logger:
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        with patch.dict(os.environ, {'DATABASE_URL': db_url}):
+            import a2a.migrations.env as env
+
+            importlib.reload(env)
+
+        # Check if sqlalchemy.engine logger level was set to INFO
+        mock_get_logger.assert_called_with('sqlalchemy.engine')
+        mock_logger.setLevel.assert_called_with(logging.INFO)
diff --git a/tests/migrations/versions/test_migration_6419d2d130f6.py b/tests/migrations/versions/test_migration_6419d2d130f6.py
new file mode 100644
index 000000000..d76a6e64d
--- /dev/null
+++ b/tests/migrations/versions/test_migration_6419d2d130f6.py
@@ -0,0 +1,310 @@
+import importlib
+import logging
+import os
+import sqlite3
+import tempfile
+
+from typing import Generator
+from unittest.mock import patch
+
+import pytest
+
+from a2a.a2a_db_cli import run_migrations
+
+
+# Explicitly import the migration module to ensure it is tracked by the coverage tool
+# when Alembic loads it dynamically.
+try:
+    importlib.import_module(
+        'a2a.migrations.versions.6419d2d130f6_add_columns_owner_last_updated'
+    )
+except (ImportError, AttributeError):
+    # This might fail if Alembic context is not initialized, which is fine for coverage purposes
+    pass
+
+
+@pytest.fixture(autouse=True)
+def mock_logging_config():
+    """Mock logging configuration function.
+
+    This prevents tests from changing global logging state
+    and interfering with other tests (like telemetry tests).
+    """
+    with patch('logging.basicConfig'), patch('logging.config.fileConfig'):
+        yield
+
+
+@pytest.fixture
+def temp_db() -> Generator[str, None, None]:
+    """Create a temporary SQLite database for testing."""
+    fd, path = tempfile.mkstemp(suffix='.db')
+    os.close(fd)
+    yield path
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def _setup_initial_schema(db_path: str) -> None:
+    """Setup initial schema without the new columns."""
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE tasks (
+            id VARCHAR(36) PRIMARY KEY,
+            context_id VARCHAR(36) NOT NULL,
+            kind VARCHAR(16) NOT NULL,
+            status TEXT,
+            artifacts TEXT,
+            history TEXT,
+            metadata TEXT
+        )
+    """)
+    cursor.execute("""
+        CREATE TABLE push_notification_configs (
+            task_id VARCHAR(36),
+            config_id VARCHAR(255),
+            config_data BLOB NOT NULL,
+            PRIMARY KEY (task_id, config_id)
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def test_migration_6419d2d130f6_full_cycle(
+    temp_db: str, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Test the full upgrade/downgrade cycle for migration 6419d2d130f6."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+
+    # 1. Setup initial schema without the new columns
+    _setup_initial_schema(temp_db)
+
+    # 2. Run Upgrade via direct call with a custom owner
+    custom_owner = 'test_owner_123'
+
+    test_args = [
+        'a2a-db',
+        '--database-url',
+        db_url,
+        '--add_columns_owner_last_updated-default-owner',
+        custom_owner,
+        'upgrade',
+        '6419d2d130f6',
+    ]
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+    # 3. Verify columns and index exist
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+
+    # Check tasks table
+    cursor.execute('PRAGMA table_info(tasks)')
+    tasks_columns = {row[1]: row for row in cursor.fetchall()}
+    assert 'owner' in tasks_columns
+    assert 'last_updated' in tasks_columns
+    assert tasks_columns['last_updated'][2] == 'DATETIME'
+
+    # Check default value for owner in tasks
+    # row[4] is dflt_value in PRAGMA table_info
+    assert tasks_columns['owner'][4] == f"'{custom_owner}'"
+
+    # Check index on tasks
+    cursor.execute('PRAGMA index_list(tasks)')
+    tasks_indexes = {row[1] for row in cursor.fetchall()}
+    assert 'idx_tasks_owner_last_updated' in tasks_indexes
+
+    # Check push_notification_configs table
+    cursor.execute('PRAGMA table_info(push_notification_configs)')
+    pnc_columns = {row[1]: row for row in cursor.fetchall()}
+    assert 'owner' in pnc_columns
+    assert (
+        'last_updated' not in pnc_columns
+    )  # Only for tables with 'kind' column
+
+    conn.close()
+
+    # 4. Run Downgrade via direct call
+    test_args = ['a2a-db', '--database-url', db_url, 'downgrade', 'base']
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+    # 5. Verify columns are gone
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+
+    # Check tasks table
+    cursor.execute('PRAGMA table_info(tasks)')
+    tasks_columns_post = {row[1] for row in cursor.fetchall()}
+    assert 'owner' not in tasks_columns_post
+    assert 'last_updated' not in tasks_columns_post
+
+    # Check index on tasks
+    cursor.execute('PRAGMA index_list(tasks)')
+    tasks_indexes_post = {row[1] for row in cursor.fetchall()}
+    assert 'idx_tasks_owner_last_updated' not in tasks_indexes_post
+
+    # Check push_notification_configs table
+    cursor.execute('PRAGMA table_info(push_notification_configs)')
+    pnc_columns_post = {row[1] for row in cursor.fetchall()}
+    assert 'owner' not in pnc_columns_post
+
+    conn.close()
+
+
+def test_migration_6419d2d130f6_custom_tables(
+    temp_db: str, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Test the migration with custom table names."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+    custom_tasks = 'custom_tasks'
+    custom_push = 'custom_push'
+
+    # 1. Setup initial schema with custom names
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+    cursor.execute(
+        f'CREATE TABLE {custom_tasks} (id VARCHAR(36) PRIMARY KEY, kind VARCHAR(16))'
+    )
+    cursor.execute(
+        f'CREATE TABLE {custom_push} (task_id VARCHAR(36), PRIMARY KEY (task_id))'
+    )
+    conn.commit()
+    conn.close()
+
+    # 2. Run Upgrade via direct call with custom table flags
+    test_args = [
+        'a2a-db',
+        '--database-url',
+        db_url,
+        '--tasks-table',
+        custom_tasks,
+        '--push-notification-configs-table',
+        custom_push,
+        'upgrade',
+        '6419d2d130f6',
+    ]
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+    # 3. Verify columns exist in custom tables
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+
+    cursor.execute(f'PRAGMA table_info({custom_tasks})')
+    columns = {row[1] for row in cursor.fetchall()}
+    assert 'owner' in columns
+    assert 'last_updated' in columns
+
+    # Check index on custom tasks table
+    cursor.execute(f'PRAGMA index_list({custom_tasks})')
+    indexes = {row[1] for row in cursor.fetchall()}
+    assert f'idx_{custom_tasks}_owner_last_updated' in indexes
+
+    cursor.execute(f'PRAGMA table_info({custom_push})')
+    columns = {row[1] for row in cursor.fetchall()}
+    assert 'owner' in columns
+
+    conn.close()
+
+
+def test_migration_6419d2d130f6_missing_tables(
+    temp_db: str, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Test that the migration handles missing tables gracefully."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+
+    # Run upgrade on empty database
+    test_args = [
+        'a2a-db',
+        '--database-url',
+        db_url,
+        'upgrade',
+        '6419d2d130f6',
+    ]
+    with patch('sys.argv', test_args), caplog.at_level(logging.WARNING):
+        run_migrations()
+
+    assert "Table 'tasks' does not exist" in caplog.text
+
+
+def test_migration_6419d2d130f6_idempotency(
+    temp_db: str, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Test that the migration is idempotent (can be run multiple times)."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+
+    # 1. Setup initial schema
+    _setup_initial_schema(temp_db)
+
+    # 2. Run Upgrade first time
+    test_args = [
+        'a2a-db',
+        '--database-url',
+        db_url,
+        'upgrade',
+        '6419d2d130f6',
+    ]
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+    # 3. Run Upgrade second time - should not fail even if columns already exist
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+
+def test_migration_6419d2d130f6_offline(
+    temp_db: str, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Test that offline mode generates the expected SQL without modifying the database."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+
+    # 1. Setup initial schema
+    _setup_initial_schema(temp_db)
+
+    # 2. Run upgrade in offline mode
+    test_args = [
+        'a2a-db',
+        '--database-url',
+        db_url,
+        '--sql',
+        'upgrade',
+        '6419d2d130f6',
+    ]
+    with patch('sys.argv', test_args):
+        run_migrations()
+
+    captured = capsys.readouterr()
+    # Verify SQL output contains key migration statements
+    assert 'ALTER TABLE tasks ADD COLUMN owner' in captured.out
+    assert 'ALTER TABLE tasks ADD COLUMN last_updated' in captured.out
+    assert 'CREATE INDEX idx_tasks_owner_last_updated' in captured.out
+    assert 'CREATE TABLE a2a_alembic_version' in captured.out
+    assert (
+        'ALTER TABLE push_notification_configs ADD COLUMN owner' in captured.out
+    )
+
+    # 3. Verify the database was NOT actually changed (since it is offline mode)
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+
+    # Verify tables exist
+    cursor.execute("SELECT name FROM sqlite_schema WHERE type='table'")
+    tables = {row[0] for row in cursor.fetchall()}
+    assert 'tasks' in tables
+    assert 'push_notification_configs' in tables
+    assert 'a2a_alembic_version' not in tables
+
+    # Verify columns were NOT added to tasks
+    cursor.execute('PRAGMA table_info(tasks)')
+    columns = {row[1] for row in cursor.fetchall()}
+    assert 'owner' not in columns
+    assert 'last_updated' not in columns
+
+    # Verify columns were NOT added to push_notification_configs
+    cursor.execute('PRAGMA table_info(push_notification_configs)')
+    columns = {row[1] for row in cursor.fetchall()}
+    assert 'owner' not in columns
+
+    conn.close()
diff --git a/tests/migrations/versions/test_migration_b5e3d1c8a2f7.py b/tests/migrations/versions/test_migration_b5e3d1c8a2f7.py
new file mode 100644
index 000000000..ad9d4aaf6
--- /dev/null
+++ b/tests/migrations/versions/test_migration_b5e3d1c8a2f7.py
@@ -0,0 +1,175 @@
+import importlib
+import os
+import sqlite3
+import tempfile
+
+from typing import Generator
+from unittest.mock import patch
+
+import pytest
+
+from a2a.a2a_db_cli import run_migrations
+
+
+# Explicitly import the migration module so it is tracked when Alembic loads it
+# dynamically. Revision id starts with a letter, so this import is valid.
+try:
+    importlib.import_module(
+        'a2a.migrations.versions.b5e3d1c8a2f7_add_task_version_and_task_events'
+    )
+except (ImportError, AttributeError):
+    pass
+
+
+REVISION = 'b5e3d1c8a2f7'
+PREV_REVISION = '38ce57e08137'
+
+
+@pytest.fixture(autouse=True)
+def mock_logging_config():
+    """Prevent tests from mutating global logging state."""
+    with patch('logging.basicConfig'), patch('logging.config.fileConfig'):
+        yield
+
+
+@pytest.fixture
+def temp_db() -> Generator[str, None, None]:
+    """Create a temporary SQLite database for testing."""
+    fd, path = tempfile.mkstemp(suffix='.db')
+    os.close(fd)
+    yield path
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def _setup_initial_schema(db_path: str) -> None:
+    """Create the base tasks/push tables the earlier migrations expect."""
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE tasks (
+            id VARCHAR(36) PRIMARY KEY,
+            context_id VARCHAR(36) NOT NULL,
+            kind VARCHAR(16) NOT NULL,
+            status TEXT,
+            artifacts TEXT,
+            history TEXT,
+            metadata TEXT
+        )
+    """)
+    cursor.execute("""
+        CREATE TABLE push_notification_configs (
+            task_id VARCHAR(36),
+            config_id VARCHAR(255),
+            config_data BLOB NOT NULL,
+            PRIMARY KEY (task_id, config_id)
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def _upgrade(db_url: str, revision: str = REVISION) -> None:
+    with patch(
+        'sys.argv',
+        ['a2a-db', '--database-url', db_url, 'upgrade', revision],
+    ):
+        run_migrations()
+
+
+def test_migration_b5e3d1c8a2f7_full_cycle(temp_db: str) -> None:
+    """Upgrade creates task_versions + task_events; downgrade reverses it."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+    _setup_initial_schema(temp_db)
+
+    # Upgrade through the whole chain up to this revision.
+    _upgrade(db_url)
+
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+
+    # tasks is untouched: no version column.
+    cursor.execute('PRAGMA table_info(tasks)')
+    tasks_columns = {row[1] for row in cursor.fetchall()}
+    assert 'version' not in tasks_columns
+
+    # task_versions table exists with the expected columns.
+    cursor.execute('PRAGMA table_info(task_versions)')
+    version_columns = {row[1] for row in cursor.fetchall()}
+    assert version_columns == {'task_id', 'owner', 'version'}
+
+    # task_events table exists with the expected columns.
+    cursor.execute('PRAGMA table_info(task_events)')
+    event_columns = {row[1] for row in cursor.fetchall()}
+    assert event_columns == {
+        'seq',
+        'task_id',
+        'owner',
+        'task_version',
+        'event_data',
+    }
+
+    # Index on task_id exists.
+    cursor.execute('PRAGMA index_list(task_events)')
+    event_indexes = {row[1] for row in cursor.fetchall()}
+    assert 'ix_task_events_task_id' in event_indexes
+    conn.close()
+
+    # Downgrade one step: both tables are gone.
+    with patch(
+        'sys.argv',
+        ['a2a-db', '--database-url', db_url, 'downgrade', PREV_REVISION],
+    ):
+        run_migrations()
+
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_schema WHERE type='table'")
+    tables = {row[0] for row in cursor.fetchall()}
+    assert 'task_events' not in tables
+    assert 'task_versions' not in tables
+    conn.close()
+
+
+def test_migration_b5e3d1c8a2f7_idempotency(temp_db: str) -> None:
+    """Running the upgrade twice must not fail."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+    _setup_initial_schema(temp_db)
+    _upgrade(db_url)
+    # Second run: both tables already exist.
+    _upgrade(db_url)
+
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_schema WHERE type='table'")
+    tables = {row[0] for row in cursor.fetchall()}
+    assert {'task_versions', 'task_events'} <= tables
+    conn.close()
+
+
+def test_migration_b5e3d1c8a2f7_offline(
+    temp_db: str, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Offline (--sql) mode emits the DDL without touching the database."""
+    db_url = f'sqlite+aiosqlite:///{temp_db}'
+    _setup_initial_schema(temp_db)
+
+    with patch(
+        'sys.argv',
+        ['a2a-db', '--database-url', db_url, '--sql', 'upgrade', REVISION],
+    ):
+        run_migrations()
+
+    out = capsys.readouterr().out
+    assert 'CREATE TABLE task_versions' in out
+    assert 'CREATE TABLE task_events' in out
+    assert 'ix_task_events_task_id' in out
+
+    # The database itself was not modified.
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_schema WHERE type='table'")
+    tables = {row[0] for row in cursor.fetchall()}
+    assert 'task_events' not in tables
+    assert 'task_versions' not in tables
+    conn.close()
diff --git a/tests/plugins/test_manager.py b/tests/plugins/test_manager.py
new file mode 100644
index 000000000..db0e479f9
--- /dev/null
+++ b/tests/plugins/test_manager.py
@@ -0,0 +1,347 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from a2a import plugins
+from a2a.client.client import ClientCallContext
+from a2a.plugins import (
+    ClientPlugin,
+    ClientRequest,
+    ClientResponse,
+    CompletePlugin,
+    ExecutionPlugin,
+    Plugin,
+    PushPlugin,
+    PushRequest,
+    PushResult,
+    SequentialPluginManager,
+    ServerPlugin,
+    ServerRequest,
+    ServerResponse,
+    TaskEventInfo,
+    TaskObserverPlugin,
+)
+from a2a.server.context import ServerCallContext
+from a2a.types.a2a_pb2 import AgentCard, Task, TaskState
+
+
+class Recorder(CompletePlugin, ExecutionPlugin, TaskObserverPlugin, PushPlugin):
+    """Appends '<name>.<hook>' to a shared log for every hook call."""
+
+    def __init__(self, name: str, log: list[str], fail: set[str] = frozenset()):
+        self.name = name
+        self.log = log
+        self.fail = fail
+
+    def _record(self, hook: str) -> None:
+        self.log.append(f'{self.name}.{hook}')
+        if hook in self.fail:
+            raise ValueError(f'{self.name}.{hook} failed')
+
+    async def before_handler_run(self, request):
+        self._record('before_handler_run')
+
+    async def after_handler_run(self, response):
+        self._record('after_handler_run')
+
+    async def before_client_request(self, request):
+        self._record('before_client_request')
+
+    async def after_client_request(self, response):
+        self._record('after_client_request')
+
+    async def before_execution(self, request_context):
+        self._record('before_execution')
+
+    async def on_execution_event(self, request_context, event):
+        self._record('on_execution_event')
+
+    async def after_execution(self, request_context, error):
+        self._record('after_execution')
+
+    async def on_task_event(self, info):
+        self._record('on_task_event')
+
+    async def before_push_send(self, request):
+        self._record('before_push_send')
+
+    async def on_push_sent(self, result):
+        self._record('on_push_sent')
+
+
+def server_request() -> ServerRequest:
+    return ServerRequest('GetTask', None, ServerCallContext())
+
+
+def client_request() -> ClientRequest:
+    return ClientRequest('GetTask', None, AgentCard(), ClientCallContext())
+
+
+def push_request() -> PushRequest:
+    return PushRequest('t-1', 'http://hook', {}, Task(id='t-1'))
+
+
+@pytest.fixture(autouse=True)
+def restore_global():
+    previous = plugins.get_global()
+    yield
+    plugins.set_global(previous)
+
+
+@pytest.mark.asyncio
+async def test_before_in_order_after_in_reverse():
+    log: list[str] = []
+    m = plugins.sequential(Recorder('a', log), Recorder('b', log))
+
+    await m.before_handler_run(server_request())
+    await m.after_handler_run(
+        ServerResponse('GetTask', None, ServerCallContext())
+    )
+    await m.before_client_request(client_request())
+    await m.after_client_request(
+        ClientResponse('GetTask', None, ClientCallContext())
+    )
+    await m.before_execution(MagicMock())
+    await m.after_execution(MagicMock(), None)
+
+    assert log == [
+        'a.before_handler_run',
+        'b.before_handler_run',
+        'b.after_handler_run',
+        'a.after_handler_run',
+        'a.before_client_request',
+        'b.before_client_request',
+        'b.after_client_request',
+        'a.after_client_request',
+        'a.before_execution',
+        'b.before_execution',
+        'b.after_execution',
+        'a.after_execution',
+    ]
+
+
+@pytest.mark.asyncio
+async def test_observers_run_in_order():
+    log: list[str] = []
+    m = plugins.sequential(Recorder('a', log), Recorder('b', log))
+    info = TaskEventInfo(
+        't-1',
+        None,
+        TaskState.TASK_STATE_SUBMITTED,
+        None,
+        Task(id='t-1'),
+        ServerCallContext(),
+    )
+
+    await m.on_task_event(info)
+    await m.on_execution_event(MagicMock(), Task())
+    await m.before_push_send(push_request())
+    await m.on_push_sent(PushResult(push_request(), 0.1, 200, None))
+
+    assert log == [
+        'a.on_task_event',
+        'b.on_task_event',
+        'a.on_execution_event',
+        'b.on_execution_event',
+        'a.before_push_send',
+        'b.before_push_send',
+        'a.on_push_sent',
+        'b.on_push_sent',
+    ]
+
+
+@pytest.mark.parametrize(
+    ('before', 'after', 'call'),
+    [
+        (
+            'before_handler_run',
+            'after_handler_run',
+            lambda m: m.before_handler_run(server_request()),
+        ),
+        (
+            'before_client_request',
+            'after_client_request',
+            lambda m: m.before_client_request(client_request()),
+        ),
+        (
+            'before_execution',
+            'after_execution',
+            lambda m: m.before_execution(MagicMock()),
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_rejection_unwinds_plugins_that_ran(before, after, call):
+    log: list[str] = []
+    m = plugins.sequential(
+        Recorder('a', log),
+        Recorder('b', log, fail={before}),
+        Recorder('c', log),
+    )
+
+    with pytest.raises(ValueError, match=f'b.{before} failed'):
+        await call(m)
+
+    # c never ran; a ran and is unwound; b raised and gets no after-hook.
+    assert log == [f'a.{before}', f'b.{before}', f'a.{after}']
+
+
+@pytest.mark.asyncio
+async def test_unwind_passes_error_to_after_hook():
+    seen: list[BaseException | None] = []
+
+    class Capture(ServerPlugin):
+        async def after_handler_run(self, response):
+            seen.append(response.error)
+
+    class Reject(ServerPlugin):
+        async def before_handler_run(self, request):
+            raise PermissionError('denied')
+
+    m = plugins.sequential(Capture(), Reject())
+    with pytest.raises(PermissionError):
+        await m.before_handler_run(server_request())
+
+    assert len(seen) == 1
+    assert isinstance(seen[0], PermissionError)
+
+
+@pytest.mark.parametrize(
+    'hook',
+    [
+        'after_handler_run',
+        'after_client_request',
+        'after_execution',
+        'on_execution_event',
+        'on_task_event',
+        'on_push_sent',
+    ],
+)
+@pytest.mark.asyncio
+async def test_after_and_observer_errors_are_swallowed(hook, caplog):
+    log: list[str] = []
+    m = plugins.sequential(Recorder('a', log, fail={hook}), Recorder('b', log))
+    calls = {
+        'after_handler_run': lambda: m.after_handler_run(
+            ServerResponse('GetTask', None, ServerCallContext())
+        ),
+        'after_client_request': lambda: m.after_client_request(
+            ClientResponse('GetTask', None, ClientCallContext())
+        ),
+        'after_execution': lambda: m.after_execution(MagicMock(), None),
+        'on_execution_event': lambda: m.on_execution_event(MagicMock(), Task()),
+        'on_task_event': lambda: m.on_task_event(MagicMock()),
+        'on_push_sent': lambda: m.on_push_sent(MagicMock()),
+    }
+
+    await calls[hook]()
+
+    assert f'a.{hook}' in log
+    assert f'b.{hook}' in log
+    assert f"A2A plugin 'a' failed in {hook}" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_before_push_send_error_propagates():
+    m = plugins.sequential(Recorder('a', [], fail={'before_push_send'}))
+    with pytest.raises(ValueError, match='before_push_send'):
+        await m.before_push_send(push_request())
+
+
+def test_plugins_filtered_by_interface():
+    class OnlyTask(TaskObserverPlugin):
+        pass
+
+    class OnlyClient(ClientPlugin):
+        pass
+
+    m = plugins.sequential(OnlyTask(), OnlyClient())
+
+    assert m.has_task_hooks
+    assert m.has_client_hooks
+    assert not m.has_server_hooks
+    assert not m.has_execution_hooks
+    assert not m.has_push_hooks
+
+
+def test_empty_manager_has_no_hooks():
+    m = SequentialPluginManager()
+    assert not any(
+        (
+            m.has_server_hooks,
+            m.has_client_hooks,
+            m.has_execution_hooks,
+            m.has_task_hooks,
+            m.has_push_hooks,
+        )
+    )
+    assert m.plugins == ()
+
+
+def test_base_plugin_manager_has_no_hooks():
+    m = plugins.PluginManager()
+    assert not m.has_server_hooks
+    assert not m.has_client_hooks
+    assert not m.has_execution_hooks
+    assert not m.has_task_hooks
+    assert not m.has_push_hooks
+
+
+@pytest.mark.asyncio
+async def test_nested_managers():
+    log: list[str] = []
+    inner = plugins.sequential(Recorder('b', log), Recorder('c', log))
+    outer = plugins.sequential(Recorder('a', log), inner)
+
+    await outer.before_handler_run(server_request())
+    await outer.after_handler_run(
+        ServerResponse('GetTask', None, ServerCallContext())
+    )
+
+    assert log == [
+        'a.before_handler_run',
+        'b.before_handler_run',
+        'c.before_handler_run',
+        'c.after_handler_run',
+        'b.after_handler_run',
+        'a.after_handler_run',
+    ]
+
+
+def test_nested_empty_manager_does_not_count_as_hooks():
+    outer = plugins.sequential(plugins.sequential())
+    assert not outer.has_server_hooks
+    assert not outer.has_push_hooks
+
+
+def test_rejects_non_plugins():
+    with pytest.raises(TypeError, match='Not A2A plugins'):
+        plugins.sequential(object())  # type: ignore[arg-type]
+
+
+@pytest.mark.asyncio
+async def test_base_hooks_are_no_ops():
+    p = CompletePlugin()
+    assert await p.before_handler_run(server_request()) is None
+    assert (
+        await p.after_client_request(
+            ClientResponse('GetTask', None, ClientCallContext())
+        )
+        is None
+    )
+    assert Plugin.name == 'unnamed'
+    e = ExecutionPlugin()
+    assert await e.on_execution_event(MagicMock(), Task()) is None
+    assert await PushPlugin().before_push_send(push_request()) is None
+
+
+def test_global_registry():
+    assert isinstance(plugins.get_global(), plugins.PluginManager)
+    m = plugins.sequential(Recorder('a', []))
+    plugins.set_global(m)
+    assert plugins.get_global() is m
+
+
+def test_set_global_requires_manager():
+    with pytest.raises(TypeError, match='sequential'):
+        plugins.set_global(Recorder('a', []))  # type: ignore[arg-type]
diff --git a/tests/pyproject.toml b/tests/pyproject.toml
new file mode 100644
index 000000000..48469954e
--- /dev/null
+++ b/tests/pyproject.toml
@@ -0,0 +1,13 @@
+[tool.ruff]
+extend = "../pyproject.toml"
+exclude = []
+
+[tool.ruff.lint]
+exclude = []
+select = ["F401", "F811", "I001"]
+
+[tool.ruff.lint.isort]
+case-sensitive = true
+combine-as-imports = true
+lines-after-imports = 2
+lines-between-types = 1
diff --git a/tests/server/agent_execution/__init__.py b/tests/server/agent_execution/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/agent_execution/test_active_task.py b/tests/server/agent_execution/test_active_task.py
new file mode 100644
index 000000000..10ce4ac49
--- /dev/null
+++ b/tests/server/agent_execution/test_active_task.py
@@ -0,0 +1,1548 @@
+import asyncio
+import contextlib
+import logging
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+import pytest_asyncio
+
+from a2a.server.agent_execution.active_task import ActiveTask, EventConsumer
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue_v2 import EventQueueSource as EventQueue
+from a2a.server.tasks.push_notification_sender import PushNotificationSender
+from a2a.server.tasks.task_manager import TaskManager
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    Message,
+    Task,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils._async_queue_compat import QueueShutDown, create_async_queue
+from a2a.utils.errors import TaskNotFoundError, UnsupportedOperationError
+
+
+logger = logging.getLogger(__name__)
+
+
+class TestActiveTask:
+    """Tests for the ActiveTask class."""
+
+    @pytest.fixture
+    def agent_executor(self) -> Mock:
+        return Mock(spec=AgentExecutor)
+
+    @pytest.fixture
+    def task_manager(self) -> Mock:
+        tm = Mock(spec=TaskManager)
+        tm.process = AsyncMock(side_effect=lambda x: x)
+        tm.get_task = AsyncMock(return_value=None)
+        tm.context_id = 'test-context-id'
+        tm._init_task_obj = Mock(return_value=Task(id='test-task-id'))
+        tm.ensure_task_id = AsyncMock(return_value=Task(id='test-task-id'))
+        tm.save_task_event = AsyncMock()
+        return tm
+
+    @pytest_asyncio.fixture
+    async def event_queue(self) -> EventQueue:
+        return EventQueue()
+
+    @pytest.fixture
+    def push_sender(self) -> Mock:
+        ps = Mock(spec=PushNotificationSender)
+        ps.send_notification = AsyncMock()
+        return ps
+
+    @pytest.fixture
+    def request_context(self) -> Mock:
+        return Mock(spec=RequestContext)
+
+    @pytest_asyncio.fixture
+    async def active_task(
+        self,
+        agent_executor: Mock,
+        task_manager: Mock,
+        push_sender: Mock,
+    ) -> ActiveTask:
+        return ActiveTask(
+            agent_executor=agent_executor,
+            task_id='test-task-id',
+            task_manager=task_manager,
+            push_sender=push_sender,
+        )
+
+    @pytest.mark.asyncio
+    async def test_active_task_already_started(
+        self, active_task: ActiveTask, request_context: Mock
+    ) -> None:
+        """Test starting a task that is already started."""
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        # Enqueuing and starting again should not raise errors
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        assert active_task._producer_task is not None
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test canceling an ActiveTask."""
+        stop_event = asyncio.Event()
+
+        async def execute_mock(req, q):
+            await stop_event.wait()
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        agent_executor.cancel = AsyncMock()
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+            )
+        ] * 10
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # Give it a moment to start
+        await asyncio.sleep(0.1)
+
+        await active_task.cancel(request_context)
+
+        agent_executor.cancel.assert_called_once()
+        stop_event.set()
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_forwards_request_metadata(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test ActiveTask.cancel passes CancelTaskRequest metadata to AgentExecutor.cancel."""
+        started = asyncio.Event()
+        stop_event = asyncio.Event()
+
+        async def execute_mock(
+            _ctx: RequestContext, _queue: EventQueue
+        ) -> None:
+            started.set()
+            await stop_event.wait()
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        agent_executor.cancel = AsyncMock()
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                context_id='ctx-1',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] * 5 + [
+            Task(
+                id='test-task-id',
+                context_id='ctx-1',
+                status=TaskStatus(state=TaskState.TASK_STATE_CANCELED),
+            )
+        ] * 5
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        await asyncio.wait_for(started.wait(), timeout=5)
+
+        cancel_req = CancelTaskRequest(
+            id='test-task-id',
+            metadata={'reason': 'user_aborted', 'actor': 'alice'},
+        )
+        await active_task.cancel(ServerCallContext(), request=cancel_req)
+
+        agent_executor.cancel.assert_awaited_once()
+        cancel_ctx: RequestContext = agent_executor.cancel.call_args.args[0]
+        assert cancel_ctx.metadata == {
+            'reason': 'user_aborted',
+            'actor': 'alice',
+        }
+        assert cancel_ctx.message is None
+        assert cancel_ctx.task_id == 'test-task-id'
+        assert cancel_ctx.context_id == 'ctx-1'
+        stop_event.set()
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_producer_cancelled_on_cancellederror(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Regression: executor.cancel() raising asyncio.CancelledError must
+        still cancel the producer task.
+
+        asyncio.CancelledError is a BaseException, so `except Exception` does
+        not catch it. The producer cancel therefore lives in a `finally`;
+        without it the producer would leak as a pending task on this path.
+        """
+        hang = asyncio.Event()
+        producer_cancelled = asyncio.Event()
+
+        async def execute_mock(req, q):
+            try:
+                await hang.wait()
+            except asyncio.CancelledError:
+                producer_cancelled.set()
+                raise
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        agent_executor.cancel = AsyncMock(side_effect=asyncio.CancelledError)
+        task_manager.get_task = AsyncMock(
+            return_value=Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        )
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        await asyncio.sleep(0.1)  # let the producer reach `await hang.wait()`
+        assert active_task._producer_task is not None
+
+        # The CancelledError from executor.cancel propagates out of cancel()...
+        with pytest.raises(asyncio.CancelledError):
+            await active_task.cancel(request_context)
+        agent_executor.cancel.assert_awaited_once()
+
+        # ...but the producer must have received the cancellation, not been
+        # left blocked on `hang.wait()`. `_run_producer` swallows the
+        # CancelledError and returns, so the executor's coroutine seeing it is
+        # the signal that `_producer_task.cancel()` actually fired. Without the
+        # `finally` this event never sets and the producer leaks pending.
+        for _ in range(50):
+            if producer_cancelled.is_set():
+                break
+            await asyncio.sleep(0.01)
+        assert producer_cancelled.is_set(), (
+            'producer was never cancelled -> it leaked as a pending task'
+        )
+        hang.set()
+        await active_task.aclose()
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_does_not_mutate_shared_task(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """cancel() must not write the terminal state onto the shared task.
+
+        get_task() returns _task_manager._current_task, which may already have
+        been yielded to a subscriber. The terminal write goes onto a copy so
+        that reference does not change under the reader.
+        """
+        stop_event = asyncio.Event()
+
+        async def execute_mock(req, q):
+            await stop_event.wait()
+
+        shared = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        agent_executor.cancel = AsyncMock()
+        task_manager.get_task = AsyncMock(return_value=shared)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        await asyncio.sleep(0.1)
+
+        result = await active_task.cancel(request_context)
+
+        # The returned task is CANCELED...
+        assert result.status.state == TaskState.TASK_STATE_CANCELED
+        # ...but the shared object get_task handed out is untouched.
+        assert result is not shared
+        assert shared.status.state == TaskState.TASK_STATE_WORKING
+        stop_event.set()
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ('final_state', 'cancel_error_message', 'expected_failed_count'),
+        [
+            (TaskState.TASK_STATE_COMPLETED, 'cancel lost the race', 0),
+            (TaskState.TASK_STATE_WORKING, 'agent cancel blew up', 1),
+        ],
+        ids=['terminal-task-not-overwritten', 'active-task-still-marks-failed'],
+    )
+    async def test_active_task_cancel_exception_marks_failed_only_when_not_terminal(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+        final_state: TaskState,
+        cancel_error_message: str,
+        expected_failed_count: int,
+    ) -> None:
+        """Regression test: FAILED is enqueued only if the task was not already terminal when cancel() failed."""
+        stop_event = asyncio.Event()
+
+        async def execute_mock(req: RequestContext, q: EventQueue) -> None:
+            await stop_event.wait()
+
+        get_task_calls = 0
+
+        async def get_task_side_effect() -> Task | None:
+            nonlocal get_task_calls
+            get_task_calls += 1
+            # start()'s existence check needs a non-terminal task so it sets _task_created.
+            if get_task_calls == 1:
+                return Task(
+                    id='test-task-id',
+                    status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+                )
+            return Task(id='test-task-id', status=TaskStatus(state=final_state))
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        agent_executor.cancel = AsyncMock(
+            side_effect=RuntimeError(cancel_error_message)
+        )
+        task_manager.get_task = AsyncMock(side_effect=get_task_side_effect)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        await asyncio.sleep(0.1)
+        # Precondition: the guard under test only applies once this is set.
+        assert active_task._task_created.is_set()
+
+        with patch.object(
+            active_task._event_queue_agent,
+            'enqueue_event',
+            wraps=active_task._event_queue_agent.enqueue_event,
+        ) as enqueue_spy:
+            with pytest.raises(RuntimeError, match=cancel_error_message):
+                await active_task.cancel(request_context)
+
+        failed_writes = [
+            call.args[0]
+            for call in enqueue_spy.await_args_list
+            if isinstance(call.args[0], TaskStatusUpdateEvent)
+            and call.args[0].status.state == TaskState.TASK_STATE_FAILED
+        ]
+        assert len(failed_writes) == expected_failed_count
+        assert all(write.task_id == 'test-task-id' for write in failed_writes)
+
+        stop_event.set()
+        await active_task.aclose()
+
+    @pytest.mark.asyncio
+    async def test_event_consumer_drops_status_update_for_terminal_task(
+        self,
+        active_task: ActiveTask,
+        task_manager: Mock,
+    ) -> None:
+        """Regression test: FAILED update enqueued before the task turned terminal must be dropped at apply-time too."""
+        task_manager.get_task = AsyncMock(
+            return_value=Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+            )
+        )
+
+        stale_failed_event = TaskStatusUpdateEvent(
+            task_id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_FAILED),
+        )
+        await active_task._event_queue_agent.enqueue_event(stale_failed_event)
+        # Round-trip through the queue so task_done() below has a matching get().
+        dequeued = await active_task._event_queue_agent.dequeue_event()
+
+        # Not started: exercising the consumer's guard directly needs no
+        # producer/consumer loop.
+        consumer = EventConsumer(active_task)
+        with patch.object(
+            active_task._event_queue_subscribers,
+            'enqueue_event',
+            wraps=active_task._event_queue_subscribers.enqueue_event,
+        ) as subscriber_spy:
+            await consumer._process_event(dequeued)
+
+        # Dropped event must reach neither TaskManager nor subscribers.
+        task_manager.ensure_task_id.assert_not_awaited()
+        task_manager.process.assert_not_awaited()
+        subscriber_spy.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_active_task_interrupted_auth(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test task interruption due to AUTH_REQUIRED."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_AUTH_REQUIRED),
+        )
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id='test-task-id',
+                    status=TaskStatus(state=TaskState.TASK_STATE_AUTH_REQUIRED),
+                )
+            )
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        events = [
+            e async for e in active_task.subscribe(request=request_context)
+        ]
+
+        result = events[0] if events else None
+        assert (
+            getattr(result, 'id', getattr(result, 'task_id', None))
+            == 'test-task-id'
+        )
+        assert result.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+
+    @pytest.mark.asyncio
+    async def test_active_task_interrupted_input(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test task interruption due to INPUT_REQUIRED."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_INPUT_REQUIRED),
+        )
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(
+                Task(
+                    id='test-task-id',
+                    status=TaskStatus(
+                        state=TaskState.TASK_STATE_INPUT_REQUIRED
+                    ),
+                )
+            )
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        events = [
+            e async for e in active_task.subscribe(request=request_context)
+        ]
+
+        result = events[-1] if events else None
+        assert result.id == 'test-task-id'
+        assert result.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    @pytest.mark.asyncio
+    async def test_active_task_producer_failure(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test ActiveTask behavior when the producer fails."""
+        agent_executor.execute = AsyncMock(
+            side_effect=ValueError('Producer crashed')
+        )
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # We need to wait a bit for the producer to fail and set the exception
+        for _ in range(10):
+            try:
+                async for _ in active_task.subscribe():
+                    pass
+            except ValueError:
+                return
+            await asyncio.sleep(0.05)
+
+        pytest.fail('Producer failure was not raised')
+
+    @pytest.mark.asyncio
+    async def test_active_task_push_notification(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        push_sender: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test push notification sending."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(task_obj)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        async for _ in active_task.subscribe(request=request_context):
+            pass
+
+        push_sender.send_notification.assert_called()
+
+    @pytest.mark.asyncio
+    async def test_active_task_consumer_failure(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test behavior when the consumer task fails."""
+        # Mock dequeue_event to raise exception
+        active_task._event_queue_agent.dequeue_event = AsyncMock(
+            side_effect=RuntimeError('Consumer crash')
+        )
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # We need to wait for the consumer to fail
+        for _ in range(10):
+            try:
+                async for _ in active_task.subscribe():
+                    pass
+            except RuntimeError as e:
+                if str(e) == 'Consumer crash':
+                    return
+            await asyncio.sleep(0.05)
+
+        pytest.fail('Consumer failure was not raised')
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_exception_handling(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test exception handling in subscribe."""
+        event = asyncio.Event()
+
+        task_manager.get_task.return_value = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+        )
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(
+                Task(
+                    id='test-task-id',
+                    status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+                )
+            )
+            await event.wait()
+            raise ValueError('Producer failure')
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        subscriber = active_task.subscribe()
+        task = await anext(subscriber)
+        assert task.status.state == TaskState.TASK_STATE_SUBMITTED
+
+        # Now trigger the exception
+        event.set()
+
+        with pytest.raises(ValueError, match='Producer failure'):
+            await anext(subscriber)
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_not_started(
+        self, active_task: ActiveTask, request_context: Mock
+    ) -> None:
+        """Test canceling a task that was never started."""
+        # TODO: Implement this test
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_already_finished(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test canceling a task that is already finished."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+
+        async def execute_mock(req, q):
+            active_task._request_queue.shutdown(immediate=True)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        async for _ in active_task.subscribe(request=request_context):
+            pass
+
+        await active_task._is_finished.wait()
+
+        # Now it is finished
+        await active_task.cancel(request_context)
+
+        # agent_executor.cancel should NOT be called
+        agent_executor.cancel.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_cancelled_during_wait(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when it is cancelled while waiting for events."""
+
+        async def slow_execute(req, q):
+            await asyncio.sleep(10)
+
+        agent_executor.execute = AsyncMock(side_effect=slow_execute)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        it = active_task.subscribe()
+        it_obj = it.__aiter__()
+
+        # This task will be waiting inside the loop in subscribe()
+        task = asyncio.create_task(it_obj.__anext__())
+        await asyncio.sleep(0.2)
+
+        task.cancel()
+
+        # The cancellation belongs to the caller, so subscribe() must re-raise
+        # it rather than end the stream as if the task had finished.
+        with pytest.raises(asyncio.CancelledError):
+            await task
+
+        await it.aclose()
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_queue_shutdown(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when the queue is shut down."""
+
+        async def long_execute(*args, **kwargs):
+            await asyncio.sleep(10)
+
+        agent_executor.execute = AsyncMock(side_effect=long_execute)
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        tapped = await active_task._event_queue_subscribers.tap()
+
+        with patch.object(
+            active_task._event_queue_subscribers, 'tap', return_value=tapped
+        ):
+            # Close the queue while subscribe is waiting
+            async def close_later():
+                await asyncio.sleep(0.2)
+                await tapped.close()
+
+            _ = asyncio.create_task(close_later())
+
+            async for _ in active_task.subscribe():
+                pass
+
+        # Should finish normally after QueueShutDown
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_yield_then_shutdown(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when an event is yielded and then the queue is shut down."""
+        msg = Message(message_id='m1')
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(msg)
+            await asyncio.sleep(0.5)
+            # Finish producer
+            active_task._request_queue.shutdown(immediate=True)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        events = [event async for event in active_task.subscribe()]
+        assert len(events) == 1
+        assert events[0] == msg
+
+    @pytest.mark.asyncio
+    async def test_active_task_task_sets_result_first(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test that enqueuing a Task sets result_available when no result yet."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        )
+
+        async def execute_mock(req, q):
+            # No result available yet
+            await q.enqueue_event(task_obj)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        events = [
+            e async for e in active_task.subscribe(request=request_context)
+        ]
+
+        result = events[-1] if events else None
+        assert result == task_obj
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_cancelled_during_yield(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe cancellation while yielding (GeneratorExit)."""
+        msg = Message(message_id='m1')
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(msg)
+            await asyncio.sleep(10)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        it = active_task.subscribe()
+        async for event in it:
+            assert event == msg
+            # Cancel while we have the event (inside the loop)
+            await it.aclose()
+            break
+
+    @pytest.mark.asyncio
+    async def test_active_task_cancel_when_already_closed(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test cancel when the event queue is already closed."""
+
+        async def execute_mock(req, q):
+            active_task._request_queue.shutdown(immediate=True)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.return_value = Task(id='test')
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # Forced queue close.
+        await active_task._event_queue_agent.close()
+        await active_task._event_queue_subscribers.close()
+
+        # Now cancel the task itself.
+        await active_task.cancel(request_context)
+        # wait() was removed, no need to wait here.
+
+        # Cancel again should not do anything.
+        await active_task.cancel(request_context)
+        # wait() was removed, no need to wait here.
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_dequeue_failure(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when dequeue_event fails on the tapped queue."""
+
+        async def slow_execute(req, q):
+            await asyncio.sleep(10)
+
+        agent_executor.execute = AsyncMock(side_effect=slow_execute)
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        mock_tapped_queue = Mock(spec=EventQueue)
+        mock_tapped_queue.dequeue_event = AsyncMock(
+            side_effect=RuntimeError('Tapped queue crash')
+        )
+        mock_tapped_queue.close = AsyncMock()
+
+        with (
+            patch.object(
+                active_task._event_queue_subscribers,
+                'tap',
+                return_value=mock_tapped_queue,
+            ),
+            pytest.raises(RuntimeError, match='Tapped queue crash'),
+        ):
+            async for _ in active_task.subscribe():
+                pass
+
+        mock_tapped_queue.close.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_active_task_consumer_interrupted_multiple_times(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Test consumer receiving multiple interrupting events."""
+        task_obj = Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_AUTH_REQUIRED),
+        )
+
+        async def execute_mock(req, q):
+            await q.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id='test-task-id',
+                    status=TaskStatus(state=TaskState.TASK_STATE_AUTH_REQUIRED),
+                )
+            )
+            await q.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id='test-task-id',
+                    status=TaskStatus(
+                        state=TaskState.TASK_STATE_INPUT_REQUIRED
+                    ),
+                )
+            )
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task.side_effect = [
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        ] + [task_obj] * 10
+
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        events = [
+            e async for e in active_task.subscribe(request=request_context)
+        ]
+
+        result = events[0] if events else None
+        assert result.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_immediate_finish(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when the task finishes immediately."""
+
+        async def execute_mock(req, q):
+            active_task._request_queue.shutdown(immediate=True)
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # Wait for it to finish
+        await active_task._is_finished.wait()
+
+        with pytest.raises(
+            UnsupportedOperationError, match=r'Task .* is already completed'
+        ):
+            async for _ in active_task.subscribe():
+                pass
+
+    @pytest.mark.asyncio
+    async def test_active_task_start_producer_immediate_error(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test start when producer fails immediately."""
+        agent_executor.execute = AsyncMock(
+            side_effect=ValueError('Quick failure')
+        )
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        # Consumer should also finish
+        with pytest.raises(ValueError, match='Quick failure'):
+            async for _ in active_task.subscribe():
+                pass
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_finished_during_wait(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test subscribe when the task finishes while waiting for an event."""
+
+        async def slow_execute(req, q):
+            # Do nothing and just finish
+            await asyncio.sleep(0.5)
+            active_task._request_queue.shutdown(immediate=True)
+
+        agent_executor.execute = AsyncMock(side_effect=slow_execute)
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        async def consume():
+            async for _ in active_task.subscribe():
+                pass
+
+        task = asyncio.create_task(consume())
+        await asyncio.sleep(0.2)
+
+        # Task is still running, subscribe is waiting.
+        # Now it finishes.
+        await asyncio.sleep(0.5)
+        await task  # Should finish normally
+
+    @pytest.mark.asyncio
+    async def test_active_task_maybe_cleanup_not_finished(
+        self,
+        agent_executor: Mock,
+        task_manager: Mock,
+        push_sender: Mock,
+    ) -> None:
+        """Test that cleanup is not called if task is not finished."""
+        on_cleanup = Mock()
+        active_task = ActiveTask(
+            agent_executor=agent_executor,
+            task_id='test-task-id',
+            task_manager=task_manager,
+            push_sender=push_sender,
+            on_cleanup=on_cleanup,
+        )
+
+        # Explicitly call private _maybe_cleanup to verify it respects finished state
+        await active_task._maybe_cleanup()
+        on_cleanup.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_inner_exception(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+    ) -> None:
+        """Test the generic exception block in subscribe."""
+
+        async def slow_execute(req, q):
+            await asyncio.sleep(10)
+
+        agent_executor.execute = AsyncMock(side_effect=slow_execute)
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+
+        mock_tapped_queue = Mock(spec=EventQueue)
+        # dequeue_event returns a task that fails
+        mock_tapped_queue.dequeue_event = AsyncMock(
+            side_effect=Exception('Inner error')
+        )
+        mock_tapped_queue.close = AsyncMock()
+
+        with (
+            patch.object(
+                active_task._event_queue_subscribers,
+                'tap',
+                return_value=mock_tapped_queue,
+            ),
+            pytest.raises(Exception, match='Inner error'),
+        ):
+            async for _ in active_task.subscribe():
+                pass
+
+    @pytest.mark.asyncio
+    @pytest.mark.timeout(5)
+    async def test_active_task_cancel_while_subscribed_frees_producer(
+        self,
+        active_task: ActiveTask,
+        agent_executor: Mock,
+        request_context: Mock,
+        task_manager: Mock,
+    ) -> None:
+        """Regression (#1322): cancelling a stream frees its producer."""
+        hang = asyncio.Event()
+        executing = asyncio.Event()
+
+        async def execute_mock(req, q):
+            executing.set()
+            await hang.wait()  # long-running work, cancelled from outside
+
+        agent_executor.execute = AsyncMock(side_effect=execute_mock)
+        task_manager.get_task = AsyncMock(
+            return_value=Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        )
+
+        await active_task.enqueue_request(request_context)
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=True
+        )
+        producer = active_task._producer_task
+        assert producer is not None
+
+        # Subscribe before cancellation so the lifecycle event requires an ack.
+        subscription = active_task.subscribe(request=request_context)
+
+        async def drain() -> None:
+            async for _event in subscription:
+                pass
+
+        reader = asyncio.create_task(drain())
+        # Ensure cancellation reaches _run_producer's cleanup path.
+        await asyncio.wait_for(executing.wait(), timeout=2)
+        producer.cancel()
+
+        # Graceful cleanup must not wait on an unacknowledged lifecycle event.
+        await asyncio.wait_for(asyncio.shield(producer), timeout=2)
+
+        reader.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await reader
+        hang.set()
+        await active_task.aclose()
+
+    @pytest.mark.asyncio
+    async def test_active_task_subscribe_acks_raised_exception(
+        self,
+        active_task: ActiveTask,
+    ) -> None:
+        """A re-raised queue exception is still acknowledged."""
+        tapped_queue = Mock(spec=EventQueue)
+        tapped_queue.dequeue_event = AsyncMock(
+            return_value=(RuntimeError('boom'), None)
+        )
+        tapped_queue.close = AsyncMock()
+
+        with (
+            patch.object(
+                active_task._event_queue_subscribers,
+                'tap',
+                return_value=tapped_queue,
+            ),
+            pytest.raises(RuntimeError, match='boom'),
+        ):
+            await anext(active_task.subscribe())
+
+        tapped_queue.task_done.assert_called_once_with()
+
+
+@pytest.mark.asyncio
+async def test_active_task_subscribe_include_initial_task():
+    agent_executor = Mock()
+    task_manager = Mock()
+    request_context = Mock(spec=RequestContext)
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    initial_task = Task(
+        id='test-task-id', status=TaskStatus(state=TaskState.TASK_STATE_WORKING)
+    )
+
+    async def execute_mock(req, q):
+        active_task._request_queue.shutdown(immediate=True)
+
+    agent_executor.execute = AsyncMock(side_effect=execute_mock)
+    task_manager.get_task = AsyncMock(return_value=initial_task)
+    task_manager.save_task_event = AsyncMock()
+
+    await active_task.enqueue_request(request_context)
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    events = [e async for e in active_task.subscribe(include_initial_task=True)]
+
+    # Verify that the first yielded event is the initial task
+    assert len(events) >= 1
+    assert events[0] == initial_task
+
+
+@pytest.mark.timeout(1)
+@pytest.mark.asyncio
+async def test_active_task_subscribe_request_parameter():
+    agent_executor = Mock()
+    task_manager = Mock()
+    request_context = Mock(spec=RequestContext)
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    async def execute_mock(req, q):
+        # We simulate the task finishing successfully, so it will emit _RequestCompleted
+        pass
+
+    agent_executor.execute = AsyncMock(side_effect=execute_mock)
+    agent_executor.cancel = AsyncMock()
+    task_manager.get_task = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+    task_manager.save_task_event = AsyncMock()
+    task_manager.process = AsyncMock(side_effect=lambda x: x)
+
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    # Pass request_context directly to subscribe without enqueuing manually
+    events = [e async for e in active_task.subscribe(request=request_context)]
+
+    # Should complete without error, and yield no events (just _RequestCompleted which is hidden)
+    assert len(events) == 0
+
+    await active_task.cancel(request_context)
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_producer_awaited_on_normal_completion():
+    """Verify producer is awaited before cleanup to prevent GC warnings.
+
+    Regression test for #1121: when the consumer finishes first (normal
+    completion path), the producer must be awaited before
+    _maybe_cleanup() releases the ActiveTask reference, otherwise asyncio
+    logs "Task was destroyed but it is pending!".
+    """
+    agent_executor = Mock()
+    task_manager = Mock()
+    cleanup_called = False
+
+    def on_cleanup(_task: ActiveTask) -> None:
+        nonlocal cleanup_called
+        cleanup_called = True
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        on_cleanup=on_cleanup,
+    )
+
+    execute_started = asyncio.Event()
+    execute_barrier = asyncio.Event()
+
+    async def execute_mock(req, q):
+        execute_started.set()
+        await execute_barrier.wait()
+
+    agent_executor.execute = AsyncMock(side_effect=execute_mock)
+    agent_executor.cancel = AsyncMock()
+    task_manager.get_task = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+    task_manager.save_task_event = AsyncMock()
+    task_manager.ensure_task_id = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+    task_manager.process = AsyncMock(side_effect=lambda x: x)
+
+    request_context = Mock(spec=RequestContext)
+    request_context.call_context = ServerCallContext()
+    request_context.context_id = 'test-context'
+    request_context.message = None
+
+    await active_task.enqueue_request(request_context)
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    await execute_started.wait()
+
+    if active_task._consumer_task:
+        active_task._consumer_task.cancel()
+
+        # Release the producer so it can finish its work and loop back
+        # to get(), where it will receive QueueShutDown.
+        execute_barrier.set()
+
+        try:
+            await active_task._consumer_task
+        except asyncio.CancelledError:
+            pass
+
+    await active_task._is_finished.wait()
+
+    assert active_task._producer_task is not None
+    assert active_task._producer_task.done(), (
+        'Producer task should be done after consumer teardown'
+    )
+    assert cleanup_called, (
+        'on_cleanup should be called after producer is drained'
+    )
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_active_task_aclose_reaps_background_tasks():
+    """aclose() drains a live producer and consumer."""
+    agent_executor = Mock()
+    task_manager = Mock()
+    request_context = Mock(spec=RequestContext)
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    async def slow_execute(req, q):
+        await asyncio.sleep(10)
+
+    agent_executor.execute = AsyncMock(side_effect=slow_execute)
+    task_manager.get_task = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+
+    await active_task.enqueue_request(request_context)
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    await active_task.aclose()
+
+    assert active_task._producer_task is not None
+    assert active_task._producer_task.done()
+    assert active_task._consumer_task is not None
+    assert active_task._consumer_task.done()
+    assert active_task._is_finished.is_set()
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_active_task_aclose_force_closes_undrained_subscriber():
+    """aclose() unblocks past an undrained subscriber sink.
+
+    Reproduces issue #1101: a graceful close(immediate=False) would block
+    forever on the leaked sink's join().
+    """
+    agent_executor = Mock()
+    task_manager = Mock()
+    request_context = Mock(spec=RequestContext)
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    async def slow_execute(req, q):
+        await asyncio.sleep(10)
+
+    agent_executor.execute = AsyncMock(side_effect=slow_execute)
+    task_manager.get_task = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+
+    await active_task.enqueue_request(request_context)
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    # Leak a subscriber sink and push an event into it without draining it.
+    leaked = await active_task._event_queue_subscribers.tap()
+    await active_task._event_queue_subscribers.enqueue_event(Message())
+    await asyncio.sleep(0.05)
+
+    await active_task.aclose()
+
+    assert active_task._producer_task is not None
+    assert active_task._producer_task.done()
+    assert leaked.is_closed()
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_active_task_aclose_never_started_shuts_down_request_queue():
+    """aclose() on a never-started task shuts down the request queue.
+
+    If start() was never called, the producer and consumer `finally` blocks
+    that normally shut down `_request_queue` never run, so without this a
+    caller parked in `enqueue_request()` would never be released.
+    """
+    active_task = ActiveTask(
+        agent_executor=Mock(),
+        task_id='test-task-id',
+        task_manager=Mock(),
+        push_sender=Mock(),
+    )
+
+    # Swap in a bounded queue and fill it so the next enqueue_request parks.
+    active_task._request_queue = create_async_queue(maxsize=1)
+    await active_task.enqueue_request(Mock(spec=RequestContext))
+    waiter = asyncio.create_task(
+        active_task.enqueue_request(Mock(spec=RequestContext))
+    )
+    await asyncio.sleep(0.05)
+    assert not waiter.done()
+
+    await active_task.aclose()
+
+    # The parked waiter is released with the shutdown error, and any
+    # subsequent enqueue fails fast instead of hanging.
+    with pytest.raises(QueueShutDown):
+        await waiter
+    with pytest.raises(QueueShutDown):
+        await active_task.enqueue_request(Mock(spec=RequestContext))
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_subscriber_taps_are_evict_on_full():
+    """Subscriber sinks opt into evict-on-full dispatch.
+
+    A subscriber can be abandoned (non-blocking send whose response already
+    returned), so its sink must never wedge dispatch for other subscribers.
+    """
+    agent_executor = Mock()
+    task_manager = Mock()
+
+    active_task = ActiveTask(
+        agent_executor=agent_executor,
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    async def slow_execute(req, q):
+        await asyncio.sleep(10)
+
+    agent_executor.execute = AsyncMock(side_effect=slow_execute)
+    task_manager.get_task = AsyncMock(
+        return_value=Task(
+            id='test-task-id',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+    await active_task.enqueue_request(Mock(spec=RequestContext))
+    await active_task.start(
+        call_context=ServerCallContext(), create_task_if_missing=True
+    )
+
+    subscriber = active_task.subscribe(include_initial_task=True)
+    task = await anext(subscriber)
+    assert task.id == 'test-task-id'
+
+    sinks = active_task._event_queue_subscribers._sinks
+    assert sinks, 'subscribe should have tapped a sink'
+    assert all(sink._evict_on_full for sink in sinks)
+
+    await subscriber.aclose()
+    background = [
+        t
+        for t in (active_task._producer_task, active_task._consumer_task)
+        if t is not None
+    ]
+    for t in background:
+        t.cancel()
+    await asyncio.gather(*background, return_exceptions=True)
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('stored_task', 'expected_error'),
+    [
+        (
+            Task(
+                id='test-task-id',
+                status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+            ),
+            UnsupportedOperationError,
+        ),
+        (None, TaskNotFoundError),
+    ],
+)
+async def test_active_task_start_setup_failure_closes_event_queues(
+    stored_task, expected_error
+):
+    """A failed start() closes both event queues.
+
+    Each EventQueueSource starts its dispatcher task when it is created, so
+    without this the dispatchers stay pending until garbage collection and
+    surface as ``Task was destroyed but it is pending!``.
+    """
+    task_manager = Mock()
+    task_manager.get_task = AsyncMock(return_value=stored_task)
+
+    active_task = ActiveTask(
+        agent_executor=Mock(),
+        task_id='test-task-id',
+        task_manager=task_manager,
+        push_sender=Mock(),
+    )
+
+    with pytest.raises(expected_error):
+        await active_task.start(
+            call_context=ServerCallContext(), create_task_if_missing=False
+        )
+
+    assert active_task._event_queue_agent._dispatcher_task.done()
+    assert active_task._event_queue_subscribers._dispatcher_task.done()
diff --git a/tests/server/agent_execution/test_active_task_registry.py b/tests/server/agent_execution/test_active_task_registry.py
new file mode 100644
index 000000000..7f0e3e46b
--- /dev/null
+++ b/tests/server/agent_execution/test_active_task_registry.py
@@ -0,0 +1,172 @@
+import asyncio
+import logging
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a.auth.user import User
+from a2a.server.agent_execution.active_task_registry import ActiveTaskRegistry
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue_v2 import EventQueue
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types.a2a_pb2 import Task, TaskState, TaskStatus
+from a2a.utils.errors import TaskNotFoundError
+
+
+class _SlowExecutor(AgentExecutor):
+    """An executor whose execute() blocks until cancelled."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        await asyncio.sleep(10)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        return None
+
+
+def _make_registry() -> ActiveTaskRegistry:
+    return ActiveTaskRegistry(
+        agent_executor=_SlowExecutor(),
+        task_store=InMemoryTaskStore(),
+    )
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_reaps_active_tasks_and_empties_registry():
+    """aclose() reaps background tasks and removes them."""
+    registry = _make_registry()
+    active = await registry.get_or_create(
+        'task-1',
+        call_context=ServerCallContext(),
+        create_task_if_missing=True,
+    )
+
+    await registry.aclose()
+
+    assert active._producer_task is not None
+    assert active._producer_task.done()
+    assert active._consumer_task is not None
+    assert active._consumer_task.done()
+    assert await registry.get('task-1') is None
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_is_idempotent():
+    """Calling aclose() repeatedly is a safe no-op."""
+    registry = _make_registry()
+    await registry.get_or_create(
+        'task-1',
+        call_context=ServerCallContext(),
+        create_task_if_missing=True,
+    )
+
+    await registry.aclose()
+    await registry.aclose()
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_on_empty_registry():
+    """aclose() with no active tasks returns immediately."""
+    registry = _make_registry()
+    await registry.aclose()
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_get_or_create_rejected_after_aclose():
+    """A closed registry refuses to create new tasks (no orphan race)."""
+    registry = _make_registry()
+    await registry.aclose()
+
+    with pytest.raises(RuntimeError):
+        await registry.get_or_create(
+            'task-1',
+            call_context=ServerCallContext(),
+            create_task_if_missing=True,
+        )
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_logs_and_swallows_task_errors(caplog):
+    """A failing ActiveTask.aclose is logged, not propagated."""
+    registry = _make_registry()
+    failing = AsyncMock()
+    failing.aclose = AsyncMock(side_effect=ValueError('boom'))
+    registry._active_tasks['bad'] = failing
+
+    with caplog.at_level(logging.ERROR):
+        await registry.aclose()
+
+    assert 'Error draining active task' in caplog.text
+
+
+class _NamedUser(User):
+    """Minimal authenticated test user identified by ``user_name``."""
+
+    def __init__(self, user_name: str) -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def _ctx(user_name: str) -> ServerCallContext:
+    return ServerCallContext(user=_NamedUser(user_name))
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_get_or_create_cache_hit_is_owner_scoped():
+    """Issue #1159: resolving a LIVE (cached) task by id is owner-scoped at the
+    registry, so a non-owner cannot retrieve another user's active task on the
+    cache-hit path. The guarantee lives at the registry, not at each call site.
+    """
+    store = InMemoryTaskStore()
+    registry = ActiveTaskRegistry(
+        agent_executor=_SlowExecutor(), task_store=store
+    )
+    alice = _ctx('alice')
+    bob = _ctx('bob')
+
+    # Alice owns the task in the store and it is live in the registry, so the
+    # next lookups take the cache-hit early return rather than the miss path.
+    await store.save(
+        Task(
+            id='task-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        ),
+        alice,
+    )
+    active = await registry.get_or_create(
+        'task-1', call_context=alice, create_task_if_missing=True
+    )
+    assert await registry.get('task-1') is not None
+
+    # Bob (non-owner) is rejected on the cache-hit path, masked as not-found.
+    with pytest.raises(TaskNotFoundError):
+        await registry.get_or_create(
+            'task-1', call_context=bob, create_task_if_missing=False
+        )
+
+    # Alice (owner) still resolves the same live task.
+    again = await registry.get_or_create(
+        'task-1', call_context=alice, create_task_if_missing=False
+    )
+    assert again is active
+
+    await registry.aclose()
diff --git a/tests/server/agent_execution/test_context.py b/tests/server/agent_execution/test_context.py
new file mode 100644
index 000000000..77c92a202
--- /dev/null
+++ b/tests/server/agent_execution/test_context.py
@@ -0,0 +1,395 @@
+import json
+import uuid
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from a2a.server.agent_execution import RequestContext
+from a2a.server.context import ServerCallContext
+from a2a.server.id_generator import IDGenerator
+from a2a.types.a2a_pb2 import (
+    CancelTaskRequest,
+    Message,
+    SendMessageRequest,
+    Task,
+)
+from a2a.utils.errors import InvalidParamsError
+from google.protobuf import struct_pb2
+
+
+class TestRequestContext:
+    """Tests for the RequestContext class."""
+
+    @pytest.fixture
+    def mock_message(self) -> Mock:
+        """Fixture for a mock Message."""
+        return Mock(spec=Message, task_id=None, context_id=None)
+
+    @pytest.fixture
+    def mock_params(self, mock_message: Mock) -> Mock:
+        """Fixture for a mock SendMessageRequest."""
+        return Mock(spec=SendMessageRequest, message=mock_message)
+
+    @pytest.fixture
+    def mock_task(self) -> Mock:
+        """Fixture for a mock Task."""
+        return Mock(spec=Task, id='task-123', context_id='context-456')
+
+    def test_init_without_params(self) -> None:
+        """Test initialization without parameters."""
+        context = RequestContext(ServerCallContext())
+        assert context.message is None
+        assert context.task_id is None
+        assert context.context_id is None
+        assert context.current_task is None
+        assert context.related_tasks == []
+
+    def test_init_with_params_no_ids(self, mock_params: Mock) -> None:
+        """Test initialization with params but no task or context IDs."""
+        with patch(
+            'uuid.uuid4',
+            side_effect=[
+                uuid.UUID('00000000-0000-0000-0000-000000000001'),
+                uuid.UUID('00000000-0000-0000-0000-000000000002'),
+            ],
+        ):
+            context = RequestContext(ServerCallContext(), request=mock_params)
+
+        assert context.message == mock_params.message
+        assert context.task_id == '00000000-0000-0000-0000-000000000001'
+        assert (
+            mock_params.message.task_id
+            == '00000000-0000-0000-0000-000000000001'
+        )
+        assert context.context_id == '00000000-0000-0000-0000-000000000002'
+        assert (
+            mock_params.message.context_id
+            == '00000000-0000-0000-0000-000000000002'
+        )
+
+    def test_init_with_task_id(self, mock_params: Mock) -> None:
+        """Test initialization with task ID provided."""
+        task_id = 'task-123'
+        context = RequestContext(
+            ServerCallContext(), request=mock_params, task_id=task_id
+        )
+
+        assert context.task_id == task_id
+        assert mock_params.message.task_id == task_id
+
+    def test_init_with_context_id(self, mock_params: Mock) -> None:
+        """Test initialization with context ID provided."""
+        context_id = 'context-456'
+        context = RequestContext(
+            ServerCallContext(), request=mock_params, context_id=context_id
+        )
+
+        assert context.context_id == context_id
+        assert mock_params.message.context_id == context_id
+
+    def test_init_with_both_ids(self, mock_params: Mock) -> None:
+        """Test initialization with both task and context IDs provided."""
+        task_id = 'task-123'
+        context_id = 'context-456'
+        context = RequestContext(
+            ServerCallContext(),
+            request=mock_params,
+            task_id=task_id,
+            context_id=context_id,
+        )
+
+        assert context.task_id == task_id
+        assert mock_params.message.task_id == task_id
+        assert context.context_id == context_id
+        assert mock_params.message.context_id == context_id
+
+    def test_init_with_task(self, mock_params: Mock, mock_task: Mock) -> None:
+        """Test initialization with a task object."""
+        context = RequestContext(
+            ServerCallContext(), request=mock_params, task=mock_task
+        )
+
+        assert context.current_task == mock_task
+
+    def test_get_user_input_no_params(self) -> None:
+        """Test get_user_input with no params returns empty string."""
+        context = RequestContext(ServerCallContext())
+        assert context.get_user_input() == ''
+
+    def test_attach_related_task(self, mock_task: Mock) -> None:
+        """Test attach_related_task adds a task to related_tasks."""
+        context = RequestContext(ServerCallContext())
+        assert len(context.related_tasks) == 0
+
+        context.attach_related_task(mock_task)
+        assert len(context.related_tasks) == 1
+        assert context.related_tasks[0] == mock_task
+
+        # Test adding multiple tasks
+        another_task = Mock(spec=Task)
+        context.attach_related_task(another_task)
+        assert len(context.related_tasks) == 2
+        assert context.related_tasks[1] == another_task
+
+    def test_current_task_property(self, mock_task: Mock) -> None:
+        """Test current_task getter and setter."""
+        context = RequestContext(ServerCallContext())
+        assert context.current_task is None
+
+        context.current_task = mock_task
+        assert context.current_task == mock_task
+
+        # Change current task
+        new_task = Mock(spec=Task)
+        context.current_task = new_task
+        assert context.current_task == new_task
+
+    def test_check_or_generate_task_id_no_params(self) -> None:
+        """Test _check_or_generate_task_id with no params does nothing."""
+        context = RequestContext(ServerCallContext())
+        context._check_or_generate_task_id()
+        assert context.task_id is None
+
+    def test_check_or_generate_task_id_with_existing_task_id(
+        self, mock_params: Mock
+    ) -> None:
+        """Test _check_or_generate_task_id with existing task ID."""
+        existing_id = 'existing-task-id'
+        mock_params.message.task_id = existing_id
+
+        context = RequestContext(ServerCallContext(), request=mock_params)
+        # The method is called during initialization
+
+        assert context.task_id == existing_id
+        assert mock_params.message.task_id == existing_id
+
+    def test_check_or_generate_task_id_with_custom_id_generator(
+        self, mock_params: Mock
+    ) -> None:
+        """Test _check_or_generate_task_id uses custom ID generator when provided."""
+        id_generator = Mock(spec=IDGenerator)
+        id_generator.generate.return_value = 'custom-task-id'
+
+        context = RequestContext(
+            ServerCallContext(),
+            request=mock_params,
+            task_id_generator=id_generator,
+        )
+        # The method is called during initialization
+
+        assert context.task_id == 'custom-task-id'
+
+    def test_check_or_generate_context_id_no_params(self) -> None:
+        """Test _check_or_generate_context_id with no params does nothing."""
+        context = RequestContext(ServerCallContext())
+        context._check_or_generate_context_id()
+        assert context.context_id is None
+
+    def test_check_or_generate_context_id_with_existing_context_id(
+        self, mock_params: Mock
+    ) -> None:
+        """Test _check_or_generate_context_id with existing context ID."""
+        existing_id = 'existing-context-id'
+        mock_params.message.context_id = existing_id
+
+        context = RequestContext(ServerCallContext(), request=mock_params)
+        # The method is called during initialization
+
+        assert context.context_id == existing_id
+        assert mock_params.message.context_id == existing_id
+
+    def test_check_or_generate_context_id_with_custom_id_generator(
+        self, mock_params: Mock
+    ) -> None:
+        """Test _check_or_generate_context_id uses custom ID generator when provided."""
+        id_generator = Mock(spec=IDGenerator)
+        id_generator.generate.return_value = 'custom-context-id'
+
+        context = RequestContext(
+            ServerCallContext(),
+            request=mock_params,
+            context_id_generator=id_generator,
+        )
+        # The method is called during initialization
+
+        assert context.context_id == 'custom-context-id'
+
+    def test_init_raises_error_on_task_id_mismatch(
+        self, mock_params: Mock, mock_task: Mock
+    ) -> None:
+        """Test that an error is raised if provided task_id mismatches task.id."""
+        with pytest.raises(InvalidParamsError) as exc_info:
+            RequestContext(
+                ServerCallContext(),
+                request=mock_params,
+                task_id='wrong-task-id',
+                task=mock_task,
+            )
+        assert 'bad task id' in exc_info.value.message
+
+    def test_init_raises_error_on_context_id_mismatch(
+        self, mock_params: Mock, mock_task: Mock
+    ) -> None:
+        """Test that an error is raised if provided context_id mismatches task.context_id."""
+        # Set a valid task_id to avoid that error
+        mock_params.message.task_id = mock_task.id
+
+        with pytest.raises(InvalidParamsError) as exc_info:
+            RequestContext(
+                ServerCallContext(),
+                request=mock_params,
+                task_id=mock_task.id,
+                context_id='wrong-context-id',
+                task=mock_task,
+            )
+
+        assert 'bad context id' in exc_info.value.message
+
+    def test_with_related_tasks_provided(self, mock_task: Mock) -> None:
+        """Test initialization with related tasks provided."""
+        related_tasks = [mock_task, Mock(spec=Task)]
+        context = RequestContext(
+            ServerCallContext(), related_tasks=related_tasks
+        )  # type: ignore[arg-type]
+
+        assert context.related_tasks == related_tasks
+        assert len(context.related_tasks) == 2
+
+    def test_message_property_without_params(self) -> None:
+        """Test message property returns None when no params are provided."""
+        context = RequestContext(ServerCallContext())
+        assert context.message is None
+
+    def test_message_property_with_params(self, mock_params: Mock) -> None:
+        """Test message property returns the message from params."""
+        context = RequestContext(ServerCallContext(), request=mock_params)
+        assert context.message == mock_params.message
+
+    def test_metadata_property_without_content(self) -> None:
+        """Test metadata property returns empty dict when no content are provided."""
+        context = RequestContext(ServerCallContext())
+        assert context.metadata == {}
+
+    def test_metadata_property_with_content(self, mock_params: Mock) -> None:
+        """Test metadata property returns the metadata from params."""
+        struct = struct_pb2.Struct()
+        struct['key'] = 'value'
+        mock_params.metadata = struct
+        context = RequestContext(ServerCallContext(), request=mock_params)
+        assert context.metadata == {'key': 'value'}
+
+    def test_metadata_property_with_real_struct_nested(self) -> None:
+        """Regression: `dict(struct)` leaves nested Struct/ListValue as raw
+        protobuf objects, breaking JSON serialization of the returned dict.
+        """
+        request = SendMessageRequest()
+        request.metadata['flat_str'] = 'value1'
+        request.metadata['nested'] = {'a': 1, 'b': [1, 2, 3]}
+
+        md = RequestContext(ServerCallContext(), request=request).metadata
+
+        assert json.loads(json.dumps(md)) == {
+            'flat_str': 'value1',
+            'nested': {'a': 1.0, 'b': [1.0, 2.0, 3.0]},
+        }
+
+    def test_init_with_existing_ids_in_message(
+        self, mock_message: Mock, mock_params: Mock
+    ) -> None:
+        """Test initialization with existing IDs in the message."""
+        mock_message.task_id = 'existing-task-id'
+        mock_message.context_id = 'existing-context-id'
+
+        context = RequestContext(ServerCallContext(), request=mock_params)
+
+        assert context.task_id == 'existing-task-id'
+        assert context.context_id == 'existing-context-id'
+        # No new UUIDs should be generated
+
+    def test_init_with_task_id_and_existing_task_id_match(
+        self, mock_params: Mock, mock_task: Mock
+    ) -> None:
+        """Test initialization succeeds when task_id matches task.id."""
+        mock_params.message.task_id = mock_task.id
+
+        context = RequestContext(
+            ServerCallContext(),
+            request=mock_params,
+            task_id=mock_task.id,
+            task=mock_task,
+        )
+
+        assert context.task_id == mock_task.id
+        assert context.current_task == mock_task
+
+    def test_init_with_context_id_and_existing_context_id_match(
+        self, mock_params: Mock, mock_task: Mock
+    ) -> None:
+        """Test initialization succeeds when context_id matches task.context_id."""
+        mock_params.message.task_id = mock_task.id  # Set matching task ID
+        mock_params.message.context_id = mock_task.context_id
+
+        context = RequestContext(
+            ServerCallContext(),
+            request=mock_params,
+            task_id=mock_task.id,
+            context_id=mock_task.context_id,
+            task=mock_task,
+        )
+
+        assert context.context_id == mock_task.context_id
+        assert context.current_task == mock_task
+
+    def test_extension_handling(self) -> None:
+        """Test that requested_extensions is exposed via RequestContext."""
+        call_context = ServerCallContext(requested_extensions={'foo', 'bar'})
+        context = RequestContext(call_context=call_context)
+
+        assert context.requested_extensions == {'foo', 'bar'}
+
+    def test_init_with_cancel_task_request_metadata(
+        self, mock_task: Mock
+    ) -> None:
+        """Test RequestContext exposes metadata from CancelTaskRequest safely."""
+        cancel_request = CancelTaskRequest(
+            id=mock_task.id,
+            metadata={
+                'reason': 'user_aborted',
+                'nested': {'attempt': 2, 'flags': ['urgent', 'manual']},
+            },
+        )
+        context = RequestContext(
+            call_context=ServerCallContext(),
+            request=cancel_request,
+            task_id=mock_task.id,
+            context_id=mock_task.context_id,
+            task=mock_task,
+        )
+
+        assert context.metadata == {
+            'reason': 'user_aborted',
+            'nested': {'attempt': 2.0, 'flags': ['urgent', 'manual']},
+        }
+        assert context.message is None
+        assert context.configuration is None
+        assert context.get_user_input() == ''
+        assert context.task_id == mock_task.id
+        assert context.context_id == mock_task.context_id
+        assert context.current_task == mock_task
+
+    def test_init_with_cancel_task_request_without_metadata(
+        self, mock_task: Mock
+    ) -> None:
+        """Test RequestContext returns empty metadata when CancelTaskRequest has none."""
+        cancel_request = CancelTaskRequest(id=mock_task.id)
+        context = RequestContext(
+            call_context=ServerCallContext(),
+            request=cancel_request,
+            task_id=mock_task.id,
+            context_id=mock_task.context_id,
+            task=mock_task,
+        )
+
+        assert context.metadata == {}
+        assert context.message is None
diff --git a/tests/server/agent_execution/test_plugin_agent_executor.py b/tests/server/agent_execution/test_plugin_agent_executor.py
new file mode 100644
index 000000000..91e8ed631
--- /dev/null
+++ b/tests/server/agent_execution/test_plugin_agent_executor.py
@@ -0,0 +1,99 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from a2a import plugins
+from a2a.server.agent_execution import AgentExecutor
+from a2a.server.agent_execution.plugin_agent_executor import (
+    PluginAgentExecutor,
+    PluginEventQueue,
+)
+from a2a.server.events import EventQueue
+from a2a.types.a2a_pb2 import Message, Part, Role
+
+
+class InnerQueue(EventQueue):
+    def __init__(self) -> None:
+        self.events: list = []
+        self.extra = 'forwarded'
+
+    async def enqueue_event(self, event) -> None:
+        self.events.append(event)
+
+
+class Collect(plugins.ExecutionPlugin):
+    def __init__(self) -> None:
+        self.log: list = []
+
+    async def before_execution(self, request_context) -> None:
+        self.log.append('before')
+
+    async def on_execution_event(self, request_context, event) -> None:
+        self.log.append(('event', event.message_id))
+
+    async def after_execution(self, request_context, error) -> None:
+        self.log.append(('after', error))
+
+
+def message(message_id: str) -> Message:
+    return Message(
+        role=Role.ROLE_AGENT, message_id=message_id, parts=[Part(text='x')]
+    )
+
+
+@pytest.mark.asyncio
+async def test_event_queue_reports_then_enqueues_and_forwards_attributes():
+    collect = Collect()
+    inner = InnerQueue()
+    queue = PluginEventQueue(inner, plugins.sequential(collect), MagicMock())
+
+    await queue.enqueue_event(message('m-1'))
+
+    assert collect.log == [('event', 'm-1')]
+    assert [e.message_id for e in inner.events] == ['m-1']
+    assert queue.extra == 'forwarded'
+    with pytest.raises(AttributeError):
+        _ = queue.missing_attribute
+
+
+@pytest.mark.asyncio
+async def test_executor_wraps_execute_and_passes_errors():
+    collect = Collect()
+
+    class Agent(AgentExecutor):
+        async def execute(self, context, event_queue):
+            await event_queue.enqueue_event(message('m-1'))
+            if context == 'fail':
+                raise ValueError('boom')
+
+        async def cancel(self, context, event_queue):
+            pass
+
+    agent = Agent()
+    executor = PluginAgentExecutor(agent, plugins.sequential(collect))
+    assert executor.inner is agent
+
+    inner = InnerQueue()
+    await executor.execute(MagicMock(), inner)
+    assert collect.log == ['before', ('event', 'm-1'), ('after', None)]
+    assert len(inner.events) == 1
+
+    collect.log.clear()
+    with pytest.raises(ValueError, match='boom'):
+        await executor.execute('fail', InnerQueue())
+    assert collect.log[-1][0] == 'after'
+    assert isinstance(collect.log[-1][1], ValueError)
+
+
+@pytest.mark.asyncio
+async def test_cancel_delegates_without_hooks():
+    collect = Collect()
+    agent = MagicMock(spec=AgentExecutor)
+    agent.cancel = AsyncMock()
+    executor = PluginAgentExecutor(agent, plugins.sequential(collect))
+    queue = InnerQueue()
+
+    await executor.cancel('ctx', queue)
+
+    agent.cancel.assert_awaited_once_with('ctx', queue)
+    assert collect.log == []
diff --git a/tests/server/agent_execution/test_simple_request_context_builder.py b/tests/server/agent_execution/test_simple_request_context_builder.py
new file mode 100644
index 000000000..ef374e364
--- /dev/null
+++ b/tests/server/agent_execution/test_simple_request_context_builder.py
@@ -0,0 +1,346 @@
+import unittest
+
+from unittest.mock import AsyncMock
+
+from a2a.auth.user import UnauthenticatedUser  # Import User types
+from a2a.server.agent_execution.context import (
+    RequestContext,  # Corrected import path
+)
+from a2a.server.agent_execution.simple_request_context_builder import (
+    SimpleRequestContextBuilder,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.id_generator import IDGenerator
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types.a2a_pb2 import (
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+
+
+# Helper to create a simple message
+def create_sample_message(
+    content: str = 'test message',
+    msg_id: str = 'msg1',
+    role: Role = Role.ROLE_USER,
+    reference_task_ids: list[str] | None = None,
+) -> Message:
+    return Message(
+        message_id=msg_id,
+        role=role,
+        parts=[Part(text=content)],
+        reference_task_ids=reference_task_ids if reference_task_ids else [],
+    )
+
+
+# Helper to create a simple task
+def create_sample_task(
+    task_id: str = 'task1',
+    status_state: TaskState = TaskState.TASK_STATE_SUBMITTED,
+    context_id: str = 'ctx1',
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=status_state),
+    )
+
+
+class TestSimpleRequestContextBuilder(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        self.mock_task_store = AsyncMock(spec=TaskStore)
+
+    def test_init_with_populate_true_and_task_store(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=True, task_store=self.mock_task_store
+        )
+        self.assertTrue(builder._should_populate_referred_tasks)
+        self.assertEqual(builder._task_store, self.mock_task_store)
+
+    def test_init_with_populate_false_task_store_none(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False, task_store=None
+        )
+        self.assertFalse(builder._should_populate_referred_tasks)
+        self.assertIsNone(builder._task_store)
+
+    def test_init_with_populate_false_task_store_provided(self) -> None:
+        # Even if populate is false, task_store might still be provided (though not used by build for related_tasks)
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False,
+            task_store=self.mock_task_store,
+        )
+        self.assertFalse(builder._should_populate_referred_tasks)
+        self.assertEqual(builder._task_store, self.mock_task_store)
+
+    async def test_build_basic_context_no_populate(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False,
+            task_store=self.mock_task_store,
+        )
+
+        params = SendMessageRequest(message=create_sample_message())
+        task_id = 'test_task_id_1'
+        context_id = 'test_context_id_1'
+        current_task = create_sample_task(
+            task_id=task_id, context_id=context_id
+        )
+        # Pass a valid User instance, e.g., UnauthenticatedUser or a mock spec'd as User
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        request_context = await builder.build(
+            params=params,
+            task_id=task_id,
+            context_id=context_id,
+            task=current_task,
+            context=server_call_context,
+        )
+
+        self.assertIsInstance(request_context, RequestContext)
+        # Access params via its properties message and configuration
+        self.assertEqual(request_context.message, params.message)
+        self.assertEqual(request_context.configuration, params.configuration)
+        self.assertEqual(request_context.task_id, task_id)
+        self.assertEqual(request_context.context_id, context_id)
+        self.assertEqual(
+            request_context.current_task, current_task
+        )  # Property is current_task
+        self.assertEqual(
+            request_context.call_context, server_call_context
+        )  # Property is call_context
+        self.assertEqual(request_context.related_tasks, [])  # Initialized to []
+        self.mock_task_store.get.assert_not_called()
+
+    async def test_build_populate_true_with_reference_task_ids(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=True, task_store=self.mock_task_store
+        )
+        ref_task_id1 = 'ref_task1'
+        ref_task_id2 = 'ref_task2_missing'
+        ref_task_id3 = 'ref_task3'
+
+        mock_ref_task1 = create_sample_task(task_id=ref_task_id1)
+        mock_ref_task3 = create_sample_task(task_id=ref_task_id3)
+
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        # Configure task_store.get mock
+        # Note: AsyncMock side_effect needs to handle multiple calls if they have different args.
+        # A simple way is a list of return values, or a function.
+        async def get_side_effect(task_id, server_call_context):
+            if task_id == ref_task_id1:
+                return mock_ref_task1
+            if task_id == ref_task_id3:
+                return mock_ref_task3
+            return None
+
+        self.mock_task_store.get = AsyncMock(side_effect=get_side_effect)
+
+        params = SendMessageRequest(
+            message=create_sample_message(
+                reference_task_ids=[ref_task_id1, ref_task_id2, ref_task_id3]
+            )
+        )
+
+        request_context = await builder.build(
+            params=params,
+            task_id='t1',
+            context_id='c1',
+            task=None,
+            context=server_call_context,
+        )
+
+        self.assertEqual(self.mock_task_store.get.call_count, 3)
+        self.mock_task_store.get.assert_any_call(
+            ref_task_id1, server_call_context
+        )
+        self.mock_task_store.get.assert_any_call(
+            ref_task_id2, server_call_context
+        )
+        self.mock_task_store.get.assert_any_call(
+            ref_task_id3, server_call_context
+        )
+
+        self.assertIsNotNone(request_context.related_tasks)
+        self.assertEqual(
+            len(request_context.related_tasks), 2
+        )  # Only non-None tasks
+        self.assertIn(mock_ref_task1, request_context.related_tasks)
+        self.assertIn(mock_ref_task3, request_context.related_tasks)
+
+    async def test_build_populate_true_params_none(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=True, task_store=self.mock_task_store
+        )
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+        request_context = await builder.build(
+            params=None,
+            task_id='t1',
+            context_id='c1',
+            task=None,
+            context=server_call_context,
+        )
+        self.assertEqual(request_context.related_tasks, [])
+        self.mock_task_store.get.assert_not_called()
+
+    async def test_build_populate_true_reference_ids_empty_or_none(
+        self,
+    ) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=True, task_store=self.mock_task_store
+        )
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        # Test with empty list
+        params_empty_refs = SendMessageRequest(
+            message=create_sample_message(reference_task_ids=[])
+        )
+        request_context_empty = await builder.build(
+            params=params_empty_refs,
+            task_id='t1',
+            context_id='c1',
+            task=None,
+            context=server_call_context,
+        )
+        self.assertEqual(
+            request_context_empty.related_tasks, []
+        )  # Should be [] if list is empty
+        self.mock_task_store.get.assert_not_called()
+
+        self.mock_task_store.get.reset_mock()  # Reset for next call
+
+        # Test with reference_task_ids=None (Pydantic model might default it to empty list or handle it)
+        # create_sample_message defaults to [] if None is passed, so this tests the same as above.
+        # To explicitly test None in Message, we'd have to bypass Pydantic default or modify helper.
+        # For now, this covers the "no IDs to process" case.
+        msg_with_no_refs = Message(
+            message_id='m2',
+            role=Role.ROLE_USER,
+            parts=[],
+            reference_task_ids=None,
+        )
+        params_none_refs = SendMessageRequest(message=msg_with_no_refs)
+        request_context_none = await builder.build(
+            params=params_none_refs,
+            task_id='t2',
+            context_id='c2',
+            task=None,
+            context=server_call_context,
+        )
+        self.assertEqual(request_context_none.related_tasks, [])
+        self.mock_task_store.get.assert_not_called()
+
+    async def test_build_populate_true_task_store_none(self) -> None:
+        # This scenario might be prevented by constructor logic if should_populate_referred_tasks is True,
+        # but testing defensively. The builder might allow task_store=None if it's set post-init,
+        # or if constructor logic changes. Current SimpleRequestContextBuilder takes it at init.
+        # If task_store is None, it should not attempt to call get.
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=True,
+            task_store=None,  # Explicitly None
+        )
+        params = SendMessageRequest(
+            message=create_sample_message(reference_task_ids=['ref1'])
+        )
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        request_context = await builder.build(
+            params=params,
+            task_id='t1',
+            context_id='c1',
+            task=None,
+            context=server_call_context,
+        )
+        # Expect related_tasks to be an empty list as task_store is None
+        self.assertEqual(request_context.related_tasks, [])
+        # No mock_task_store to check calls on, this test is mostly for graceful handling.
+
+    async def test_build_populate_false_with_reference_task_ids(self) -> None:
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False,
+            task_store=self.mock_task_store,
+        )
+        params = SendMessageRequest(
+            message=create_sample_message(
+                reference_task_ids=['ref_task_should_not_be_fetched']
+            )
+        )
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        request_context = await builder.build(
+            params=params,
+            task_id='t1',
+            context_id='c1',
+            task=None,
+            context=server_call_context,
+        )
+        self.assertEqual(request_context.related_tasks, [])
+        self.mock_task_store.get.assert_not_called()
+
+    async def test_build_with_custom_id_generators(self) -> None:
+        mock_task_id_generator = AsyncMock(spec=IDGenerator)
+        mock_context_id_generator = AsyncMock(spec=IDGenerator)
+        mock_task_id_generator.generate.return_value = 'custom_task_id'
+        mock_context_id_generator.generate.return_value = 'custom_context_id'
+
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False,
+            task_store=self.mock_task_store,
+            task_id_generator=mock_task_id_generator,
+            context_id_generator=mock_context_id_generator,
+        )
+        params = SendMessageRequest(message=create_sample_message())
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        request_context = await builder.build(
+            params=params,
+            task_id=None,
+            context_id=None,
+            task=None,
+            context=server_call_context,
+        )
+
+        mock_task_id_generator.generate.assert_called_once()
+        mock_context_id_generator.generate.assert_called_once()
+        self.assertEqual(request_context.task_id, 'custom_task_id')
+        self.assertEqual(request_context.context_id, 'custom_context_id')
+
+    async def test_build_with_provided_ids_and_custom_id_generators(
+        self,
+    ) -> None:
+        mock_task_id_generator = AsyncMock(spec=IDGenerator)
+        mock_context_id_generator = AsyncMock(spec=IDGenerator)
+
+        builder = SimpleRequestContextBuilder(
+            should_populate_referred_tasks=False,
+            task_store=self.mock_task_store,
+            task_id_generator=mock_task_id_generator,
+            context_id_generator=mock_context_id_generator,
+        )
+        params = SendMessageRequest(message=create_sample_message())
+        server_call_context = ServerCallContext(user=UnauthenticatedUser())
+
+        provided_task_id = 'provided_task_id'
+        provided_context_id = 'provided_context_id'
+
+        request_context = await builder.build(
+            params=params,
+            task_id=provided_task_id,
+            context_id=provided_context_id,
+            task=None,
+            context=server_call_context,
+        )
+
+        mock_task_id_generator.generate.assert_not_called()
+        mock_context_id_generator.generate.assert_not_called()
+        self.assertEqual(request_context.task_id, provided_task_id)
+        self.assertEqual(request_context.context_id, provided_context_id)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/server/cluster/__init__.py b/tests/server/cluster/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/cluster/conftest.py b/tests/server/cluster/conftest.py
new file mode 100644
index 000000000..8e8a983aa
--- /dev/null
+++ b/tests/server/cluster/conftest.py
@@ -0,0 +1,416 @@
+import asyncio
+import contextlib
+import threading
+
+from collections.abc import AsyncGenerator
+
+import pytest
+
+from a2a.auth.user import User
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.cluster import (
+    ConcurrentTaskModificationError,
+    StoredTask,
+    TaskEventStream,
+    TaskVersion,
+    VersionedEvent,
+    VersionedTaskStore,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.events.event_queue import Event
+from a2a.server.owner_resolver import OwnerResolver, resolve_user_scope
+from a2a.server.request_handlers.default_request_handler_v2 import (
+    DefaultRequestHandlerV2,
+)
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.tasks.task_updater import TaskUpdater
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    Task,
+    TaskState,
+)
+from a2a.utils.constants import TERMINAL_TASK_STATES
+
+
+# --- In-memory cluster doubles ----------------------------------------------
+
+
+class VersionedInMemoryTaskStore(VersionedTaskStore):
+    """`VersionedTaskStore` backed by in-process dictionaries.
+
+    Holds one integer version per (owner, task_id). `save` performs a
+    compare-and-swap against `prev_version` and raises
+    `ConcurrentTaskModificationError` on mismatch. Reads and list operations
+    delegate to a wrapped `InMemoryTaskStore` for the task data itself.
+    """
+
+    def __init__(
+        self, owner_resolver: OwnerResolver = resolve_user_scope
+    ) -> None:
+        self._owner_resolver = owner_resolver
+        self._store = InMemoryTaskStore()
+        # Maps owner to a mapping of task_id to its current integer version.
+        self._versions: dict[str, dict[str, int]] = {}
+        self._lock = threading.RLock()
+
+    def _current_version_locked(self, owner: str, task_id: str) -> int:
+        return self._versions.get(owner, {}).get(task_id, 0)
+
+    async def save(
+        self,
+        task: Task,
+        *,
+        event: Event | None,
+        prev: Task | None,
+        prev_version: TaskVersion,
+        context: ServerCallContext,
+    ) -> TaskVersion:
+        """Persists `task`, bumping its version, with a compare-and-swap.
+
+        Raises `ConcurrentTaskModificationError` if `prev_version` does not
+        match the currently stored version. `TaskVersion.MISSING` skips the
+        check; a write moving `task` to CANCELED overwrites a non-terminal
+        stored task without a version check, and raises when it is terminal
+        or absent.
+        """
+        del event, prev  # in-memory store keeps no event log
+        owner = self._owner_resolver(context)
+        with self._lock:
+            stored = self._current_version_locked(owner, task_id=task.id)
+            if task.status.state == TaskState.TASK_STATE_CANCELED:
+                current = await self._store.get(task.id, context)
+                if (
+                    current is None
+                    or current.status.state in TERMINAL_TASK_STATES
+                ):
+                    raise ConcurrentTaskModificationError(task.id)
+            elif not prev_version.is_missing:
+                if stored == 0:
+                    raise ConcurrentTaskModificationError(task.id)
+                if TaskVersion(stored) != prev_version:
+                    raise ConcurrentTaskModificationError(task.id)
+            new_version = stored + 1
+            await self._store.save(task, context)
+            self._versions.setdefault(owner, {})[task.id] = new_version
+            return TaskVersion(new_version)
+
+    async def get(
+        self, task_id: str, context: ServerCallContext
+    ) -> StoredTask | None:
+        """Returns the task with its current version, or None if absent."""
+        owner = self._owner_resolver(context)
+        with self._lock:
+            task = await self._store.get(task_id, context)
+            if task is None:
+                return None
+            stored = self._current_version_locked(owner, task_id)
+            return StoredTask(task, TaskVersion(stored))
+
+    async def list(
+        self,
+        params: ListTasksRequest,
+        context: ServerCallContext,
+    ) -> ListTasksResponse:
+        """Lists tasks via the wrapped in-memory store."""
+        return await self._store.list(params, context)
+
+    async def delete(self, task_id: str, context: ServerCallContext) -> None:
+        """Deletes a task and forgets its version."""
+        owner = self._owner_resolver(context)
+        with self._lock:
+            await self._store.delete(task_id, context)
+            owner_versions = self._versions.get(owner)
+            if owner_versions is not None:
+                owner_versions.pop(task_id, None)
+                if not owner_versions:
+                    del self._versions[owner]
+
+
+class InMemoryTaskEventStream(TaskEventStream):
+    """`TaskEventStream` that fans out to in-process subscribers.
+
+    `publish` delivers to every current subscriber of the task; `subscribe`
+    returns an async iterator backed by a per-subscriber queue and filters on
+    the caller's `after` version.
+    """
+
+    def __init__(self) -> None:
+        # {task_id: set of subscriber queues}
+        self._subscribers: dict[str, set[asyncio.Queue[VersionedEvent]]] = {}
+        self._lock = asyncio.Lock()
+
+    async def publish(self, task_id: str, event: VersionedEvent) -> None:
+        """Delivers `event` to all current subscribers of `task_id`."""
+        async with self._lock:
+            queues = list(self._subscribers.get(task_id, ()))
+        for queue in queues:
+            await queue.put(event)
+
+    async def subscribe(  # type: ignore[override]
+        self, task_id: str, *, after: TaskVersion
+    ) -> AsyncGenerator[VersionedEvent, None]:
+        """Yields events for `task_id` published after this call, newer than `after`."""
+        queue: asyncio.Queue[VersionedEvent] = asyncio.Queue()
+        async with self._lock:
+            self._subscribers.setdefault(task_id, set()).add(queue)
+        try:
+            while True:
+                versioned = await queue.get()
+                if versioned.version.is_after(after):
+                    yield versioned
+        finally:
+            async with self._lock:
+                subs = self._subscribers.get(task_id)
+                if subs is not None:
+                    subs.discard(queue)
+                    if not subs:
+                        del self._subscribers[task_id]
+
+    async def destroy(self, task_id: str) -> None:
+        """Drops all subscribers for `task_id`."""
+        async with self._lock:
+            self._subscribers.pop(task_id, None)
+
+
+# --- Identity / context helpers ---------------------------------------------
+
+
+class SampleUser(User):
+    """Minimal authenticated User for tests."""
+
+    def __init__(self, user_name: str = 'test_user') -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def make_context(user: str = 'test_user') -> ServerCallContext:
+    """Builds a ServerCallContext for the given user name."""
+    return ServerCallContext(user=SampleUser(user))
+
+
+def streaming_agent_card() -> AgentCard:
+    """An AgentCard that advertises streaming support."""
+    return AgentCard(capabilities=AgentCapabilities(streaming=True))
+
+
+def build_send_request(
+    text: str,
+    task_id: str = '',
+    context_id: str = '',
+    message_id: str = 'm',
+) -> SendMessageRequest:
+    """Builds a SendMessageRequest, optionally continuing an existing task."""
+    msg = Message(
+        role=Role.ROLE_USER,
+        message_id=message_id,
+        parts=[Part(text=text)],
+    )
+    if task_id:
+        msg.task_id = task_id
+    if context_id:
+        msg.context_id = context_id
+    return SendMessageRequest(message=msg)
+
+
+async def drain(agen) -> None:  # noqa: ANN001
+    """Consumes an async generator to completion, swallowing exceptions."""
+    with contextlib.suppress(Exception):
+        async for _ in agen:
+            pass
+
+
+async def wait_for_state(
+    store: VersionedTaskStore,
+    task_id: str,
+    state: TaskState,
+    context: ServerCallContext,
+    *,
+    tries: int = 100,
+    delay: float = 0.02,
+) -> None:
+    """Polls the store until the task reaches `state` (for async persistence)."""
+    for _ in range(tries):
+        stored = await store.get(task_id, context)
+        if stored is not None and stored.task.status.state == state:
+            return
+        await asyncio.sleep(delay)
+    raise AssertionError(f'Task {task_id} did not reach {state} in time')
+
+
+# --- Reusable agent executors -----------------------------------------------
+
+
+class CompletingAgent(AgentExecutor):
+    """Creates the task if needed, goes WORKING, then completes."""
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class ControlledAgent(AgentExecutor):
+    """Creates a task, goes WORKING, then completes only when released.
+
+    `working` is set once execution reaches WORKING; the agent then waits on
+    `release` before emitting an artifact and completing. Useful for observing a
+    task mid-flight from another replica.
+    """
+
+    def __init__(self) -> None:
+        self.working = asyncio.Event()
+        self.release = asyncio.Event()
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        self.working.set()
+        await self.release.wait()
+        await updater.add_artifact([Part(text='result')])
+        await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class LongRunningAgent(AgentExecutor):
+    """Goes WORKING then loops, saving periodically until aborted.
+
+    Periodic saves let a remote cancel be observed as a CAS conflict, which
+    aborts the execution (`aborted` is set on CancelledError).
+    """
+
+    def __init__(self) -> None:
+        self.working = asyncio.Event()
+        self.aborted = asyncio.Event()
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        self.working.set()
+        try:
+            for _ in range(200):
+                await asyncio.sleep(0.05)
+                await updater.update_status(
+                    TaskState.TASK_STATE_WORKING,
+                    message=updater.new_agent_message([Part(text='tick')]),
+                )
+        except asyncio.CancelledError:
+            self.aborted.set()
+            raise
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+class InputRequiredThenCompleteAgent(AgentExecutor):
+    """Asks for input until two user turns exist, then completes.
+
+    Derives the turn purely from durable task history, so it behaves correctly
+    regardless of which replica runs each turn.
+    """
+
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        task = context.current_task
+        if task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        user_msgs = 0
+        if task is not None:
+            user_msgs = sum(1 for m in task.history if m.role == Role.ROLE_USER)
+
+        if task is None or user_msgs <= 1:
+            await updater.requires_input(
+                message=updater.new_agent_message([Part(text='need input')])
+            )
+        else:
+            await updater.complete()
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+# --- Replica / infra factories ----------------------------------------------
+
+
+def make_replica(
+    store: VersionedTaskStore,
+    stream: TaskEventStream,
+    agent: AgentExecutor,
+) -> DefaultRequestHandlerV2:
+    """Builds a handler ('replica') wired to a shared store and stream."""
+    return DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=store,
+        agent_card=streaming_agent_card(),
+        event_stream=stream,
+    )
+
+
+# --- Fixtures ----------------------------------------------------------------
+
+
+@pytest.fixture
+def shared_store() -> VersionedInMemoryTaskStore:
+    """A versioned in-memory store shared across replicas in a test."""
+    return VersionedInMemoryTaskStore()
+
+
+@pytest.fixture
+def shared_stream() -> InMemoryTaskEventStream:
+    """An in-memory event stream shared across replicas in a test."""
+    return InMemoryTaskEventStream()
+
+
+@pytest.fixture
+def context() -> ServerCallContext:
+    """A default server call context for 'test_user'."""
+    return make_context()
diff --git a/tests/server/cluster/test_cancel_multireplica.py b/tests/server/cluster/test_cancel_multireplica.py
new file mode 100644
index 000000000..bc270d50f
--- /dev/null
+++ b/tests/server/cluster/test_cancel_multireplica.py
@@ -0,0 +1,199 @@
+import asyncio
+import contextlib
+
+import pytest
+
+from a2a.types.a2a_pb2 import CancelTaskRequest, TaskState
+from a2a.utils.errors import (
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+
+from .conftest import (
+    CompletingAgent,
+    InputRequiredThenCompleteAgent,
+    LongRunningAgent,
+    build_send_request,
+    drain,
+    make_context,
+    make_replica,
+    wait_for_state,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(15)
+async def test_cancel_on_non_owning_replica_stops_remote_agent(
+    shared_store, shared_stream, context
+) -> None:
+    agent = LongRunningAgent()
+    replica_a = make_replica(shared_store, shared_stream, agent)
+    replica_b = make_replica(shared_store, shared_stream, agent)
+    try:
+        a_task = asyncio.create_task(
+            drain(
+                replica_a.on_message_send_stream(
+                    build_send_request('go', message_id='m1'), context
+                )
+            )
+        )
+        await asyncio.wait_for(agent.working.wait(), timeout=5)
+
+        task_id = next(
+            iter(replica_a._active_task_registry._active_tasks)  # noqa: SLF001
+        )
+        await wait_for_state(
+            shared_store, task_id, TaskState.TASK_STATE_WORKING, context
+        )
+
+        # Cancel from B (not running the agent).
+        result = await replica_b.on_cancel_task(
+            CancelTaskRequest(id=task_id), context
+        )
+        assert result.status.state == TaskState.TASK_STATE_CANCELED
+
+        # A's agent observes the CAS conflict and aborts; its stream ends.
+        await asyncio.wait_for(agent.aborted.wait(), timeout=8)
+        await asyncio.wait_for(a_task, timeout=8)
+
+        final = await shared_store.get(task_id, context)
+        assert final is not None
+        assert final.task.status.state == TaskState.TASK_STATE_CANCELED
+    finally:
+        await replica_a.aclose()
+        await replica_b.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_second_cancel_is_not_cancelable(
+    shared_store, shared_stream, context
+) -> None:
+    agent = LongRunningAgent()
+    handler = make_replica(shared_store, shared_stream, agent)
+    other = make_replica(shared_store, shared_stream, agent)
+    try:
+        a_task = asyncio.create_task(
+            drain(
+                handler.on_message_send_stream(
+                    build_send_request('go', message_id='m1'), context
+                )
+            )
+        )
+        await asyncio.wait_for(agent.working.wait(), timeout=5)
+        task_id = next(
+            iter(handler._active_task_registry._active_tasks)  # noqa: SLF001
+        )
+        await wait_for_state(
+            shared_store, task_id, TaskState.TASK_STATE_WORKING, context
+        )
+
+        r1 = await other.on_cancel_task(CancelTaskRequest(id=task_id), context)
+        assert r1.status.state == TaskState.TASK_STATE_CANCELED
+        # A cancelled task is terminal, so a second cancel is rejected.
+        with pytest.raises(TaskNotCancelableError):
+            await other.on_cancel_task(CancelTaskRequest(id=task_id), context)
+        stored = await shared_store.get(task_id, context)
+        assert stored is not None
+        assert stored.task.status.state == TaskState.TASK_STATE_CANCELED
+        with contextlib.suppress(Exception):
+            await asyncio.wait_for(a_task, timeout=8)
+    finally:
+        await handler.aclose()
+        await other.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_cancel_completed_task_raises_not_cancelable(
+    shared_store, shared_stream, context
+) -> None:
+    handler = make_replica(shared_store, shared_stream, CompletingAgent())
+    try:
+        result = await handler.on_message_send(
+            build_send_request('go', message_id='m1'), context
+        )
+        assert result.status.state == TaskState.TASK_STATE_COMPLETED
+        with pytest.raises(TaskNotCancelableError):
+            await handler.on_cancel_task(
+                CancelTaskRequest(id=result.id), context
+            )
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_cancel_absent_task_raises_not_found(
+    shared_store, shared_stream, context
+) -> None:
+    handler = make_replica(shared_store, shared_stream, CompletingAgent())
+    try:
+        with pytest.raises(TaskNotFoundError):
+            await handler.on_cancel_task(CancelTaskRequest(id='nope'), context)
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_cancel_non_owner_rejected(shared_store, shared_stream) -> None:
+    handler = make_replica(shared_store, shared_stream, CompletingAgent())
+    try:
+        result = await handler.on_message_send(
+            build_send_request('go', message_id='m1'), make_context('alice')
+        )
+        with pytest.raises(TaskNotFoundError):
+            await handler.on_cancel_task(
+                CancelTaskRequest(id=result.id), make_context('bob')
+            )
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_follow_up_after_remote_cancel_of_waiting_task_is_rejected(
+    shared_store, shared_stream, context
+) -> None:
+    """A task waits for input on A and is cancelled from B. A follow-up routed
+    to A is rejected rather than reviving the task, and A drops the task."""
+    agent = InputRequiredThenCompleteAgent()
+    replica_a = make_replica(shared_store, shared_stream, agent)
+    replica_b = make_replica(shared_store, shared_stream, agent)
+    try:
+        r1 = await replica_a.on_message_send(
+            build_send_request('q1', message_id='m1'), context
+        )
+        assert r1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        registry_a = replica_a._active_task_registry  # noqa: SLF001
+        assert await registry_a.get(r1.id) is not None
+
+        cancelled = await replica_b.on_cancel_task(
+            CancelTaskRequest(id=r1.id), context
+        )
+        assert cancelled.status.state == TaskState.TASK_STATE_CANCELED
+
+        with pytest.raises(UnsupportedOperationError, match='terminal state'):
+            await replica_a.on_message_send(
+                build_send_request(
+                    'a',
+                    task_id=r1.id,
+                    context_id=r1.context_id,
+                    message_id='m2',
+                ),
+                context,
+            )
+
+        final = await shared_store.get(r1.id, context)
+        assert final is not None
+        assert final.task.status.state == TaskState.TASK_STATE_CANCELED
+        for _ in range(100):
+            if await registry_a.get(r1.id) is None:
+                break
+            await asyncio.sleep(0.01)
+        assert await registry_a.get(r1.id) is None
+    finally:
+        await replica_a.aclose()
+        await replica_b.aclose()
diff --git a/tests/server/cluster/test_database_event_stream.py b/tests/server/cluster/test_database_event_stream.py
new file mode 100644
index 000000000..5a0b025be
--- /dev/null
+++ b/tests/server/cluster/test_database_event_stream.py
@@ -0,0 +1,426 @@
+"""Tests for `DatabaseTaskEventStream` including a multi-replica simulation."""
+
+import asyncio
+import contextlib
+import os
+import uuid
+import warnings
+
+from collections.abc import AsyncGenerator
+
+import pytest
+import pytest_asyncio
+
+from _pytest.mark.structures import ParameterSet
+
+
+pytest.importorskip('sqlalchemy', reason='Database tests require SQLAlchemy')
+
+from a2a.auth.user import User
+from a2a.server.cluster import TaskVersion, VersionedEvent
+from a2a.server.cluster.database_event_stream import (
+    DatabaseTaskEventStream,
+    stream_response_to_event,
+)
+from a2a.server.cluster.database_task_store import VersionedDatabaseTaskStore
+from a2a.server.cluster.event_stream import (
+    TaskEventStream,
+    _stream_accepts_context,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.models import Base
+from a2a.server.owner_resolver import resolve_user_scope
+from a2a.types.a2a_pb2 import (
+    Message,
+    Part,
+    Role,
+    StreamResponse,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+
+
+def _enforce_sqlite_foreign_keys(engine: AsyncEngine) -> None:
+    """Make SQLite enforce foreign keys, matching Postgres and MySQL.
+
+    SQLite ignores foreign keys unless asked, so without this a FK bug passes
+    the SQLite tests and only fails against the real engines in CI.
+    """
+    if engine.dialect.name != 'sqlite':
+        return
+
+    @event.listens_for(engine.sync_engine, 'connect')
+    def _set_sqlite_pragma(dbapi_conn, _):  # noqa: ANN001, ANN202
+        dbapi_conn.execute('PRAGMA foreign_keys=ON')
+
+
+class SampleUser(User):
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+POSTGRES_TEST_DSN = os.environ.get('POSTGRES_TEST_DSN')
+MYSQL_TEST_DSN = os.environ.get('MYSQL_TEST_DSN')
+
+
+def _sqlite_dsn() -> str:
+    # Unique shared-cache in-memory DB per test so multiple engines see the
+    # same data while different tests never collide.
+    name = f'eventstream_{uuid.uuid4().hex}'
+    return f'sqlite+aiosqlite:///file:{name}?mode=memory&cache=shared&uri=true'
+
+
+DB_CONFIGS: list[ParameterSet | tuple[str | None, str]] = [
+    pytest.param(('sqlite', 'sqlite'), id='sqlite')
+]
+if POSTGRES_TEST_DSN:
+    DB_CONFIGS.append(
+        pytest.param((POSTGRES_TEST_DSN, 'postgresql'), id='postgresql')
+    )
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'postgresql'),
+            marks=pytest.mark.skip(reason='POSTGRES_TEST_DSN not set'),
+            id='postgresql_skipped',
+        )
+    )
+if MYSQL_TEST_DSN:
+    DB_CONFIGS.append(pytest.param((MYSQL_TEST_DSN, 'mysql'), id='mysql'))
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'mysql'),
+            marks=pytest.mark.skip(reason='MYSQL_TEST_DSN not set'),
+            id='mysql_skipped',
+        )
+    )
+
+
+def create_task(task_id: str = 'task-abc') -> Task:
+    return Task(
+        id=task_id,
+        context_id='ctx',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+
+def status_event(
+    task_id: str = 'task-abc',
+    state: TaskState = TaskState.TASK_STATE_WORKING,
+) -> TaskStatusUpdateEvent:
+    return TaskStatusUpdateEvent(
+        task_id=task_id,
+        context_id='ctx',
+        status=TaskStatus(state=state),
+    )
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def db_url(request) -> AsyncGenerator[str, None]:
+    param, dialect = request.param
+    if param is None:
+        pytest.skip(f'DSN for {dialect} not set.')
+    url = _sqlite_dsn() if param == 'sqlite' else param
+
+    engine = create_async_engine(url)
+    _enforce_sqlite_foreign_keys(engine)
+    # Keep one connection open for the whole test so a shared-cache in-memory
+    # SQLite database is not torn down while other engines connect to it.
+    keepalive = await engine.connect()
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        yield url
+    finally:
+        await keepalive.close()
+        await engine.dispose()
+
+
+# --- Pure serialization helper tests (no DB needed) ---
+
+
+def test_stream_response_to_event_roundtrips_all_kinds() -> None:
+    task = create_task()
+    msg = Message(
+        message_id='m1', role=Role.ROLE_AGENT, parts=[Part(text='hi')]
+    )
+    status = status_event()
+    artifact = TaskArtifactUpdateEvent(task_id='task-abc', context_id='ctx')
+
+    for event in (task, msg, status, artifact):
+        response = StreamResponse()
+        # Round-trip through serialize to mimic DB storage.
+        from a2a.utils.proto_utils import to_stream_response
+
+        response = to_stream_response(event)
+        raw = response.SerializeToString()
+        parsed = StreamResponse()
+        parsed.ParseFromString(raw)
+        assert stream_response_to_event(parsed) == event
+
+
+def test_stream_response_to_event_raises_on_empty() -> None:
+    with pytest.raises(ValueError, match='no known payload'):
+        stream_response_to_event(StreamResponse())
+
+
+def test_as_int_rejects_non_integer_version() -> None:
+    from a2a.server.cluster.database_event_stream import _as_int
+
+    with pytest.raises(TypeError, match='integer versions'):
+        _as_int(TaskVersion('etag'))
+
+
+class _LegacyStream(TaskEventStream):
+    """A `TaskEventStream` with no `context` support, for compat testing."""
+
+    async def publish(self, task_id: str, event: VersionedEvent) -> None:
+        pass
+
+    async def subscribe(
+        self, task_id: str, *, after: TaskVersion
+    ) -> AsyncGenerator[VersionedEvent, None]:
+        return
+        yield  # unreachable; makes this an async generator function
+
+    async def destroy(self, task_id: str) -> None:
+        pass
+
+
+def test_stream_accepts_context_warns_once_per_type() -> None:
+    """A non-updated stream is detected once and cached, not re-warned per call."""
+    stream = _LegacyStream()
+    with pytest.warns(DeprecationWarning, match='does not accept'):
+        assert _stream_accepts_context(stream, 'publish') is False
+    with warnings.catch_warnings():
+        warnings.simplefilter('error')
+        assert _stream_accepts_context(stream, 'publish') is False
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_initialize_creates_table_and_is_idempotent(
+    tmp_path,
+) -> None:
+    # A dedicated file-backed SQLite DB (not shared-cache in-memory) so
+    # create_table=True owns the schema with no cross-engine contention.
+    url = f'sqlite+aiosqlite:///{tmp_path / "events.db"}'
+    engine = create_async_engine(url)
+    try:
+        stream = DatabaseTaskEventStream(engine=engine, create_table=True)
+        await stream.initialize()
+        # Second call is a no-op (already initialized) -> early-return path.
+        await stream.initialize()
+        # Subscribing seeds the cursor from an empty table (0) without error.
+        agen = stream.subscribe('task-abc', after=TaskVersion.MISSING)
+        consumer = asyncio.ensure_future(agen.__anext__())
+        await asyncio.sleep(0.05)
+        consumer.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await consumer
+        await agen.aclose()
+    finally:
+        await engine.dispose()
+
+
+# --- Integration tests (shared DB across store + stream) ---
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_stream_delivers_events_written_by_store(db_url: str) -> None:
+    """A store writes events; a stream on a SEPARATE engine reads them.
+
+    This simulates the producing replica (store) and a subscribing replica
+    (stream) sharing one database.
+    """
+    store_engine = create_async_engine(db_url)
+    stream_engine = create_async_engine(db_url)
+    _enforce_sqlite_foreign_keys(store_engine)
+    _enforce_sqlite_foreign_keys(stream_engine)
+    try:
+        store = VersionedDatabaseTaskStore(
+            engine=store_engine, create_table=False
+        )
+        stream = DatabaseTaskEventStream(
+            engine=stream_engine, create_table=False, poll_interval_s=0.05
+        )
+        await store.initialize()
+        await stream.initialize()
+
+        # Snapshot version (as a subscriber would have after reading the task).
+        v1 = await store.save(
+            create_task(),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+
+        received: list[TaskState] = []
+
+        async def consume() -> None:
+            async for ve in stream.subscribe('task-abc', after=v1):
+                received.append(ve.event.status.state)
+                if ve.event.status.state == TaskState.TASK_STATE_COMPLETED:
+                    return
+
+        consumer = asyncio.create_task(consume())
+        await asyncio.sleep(0.1)  # subscriber captures the tail cursor
+
+        # Producer writes two events with the task, in transaction.
+        v2 = await store.save(
+            create_task(),
+            event=status_event(state=TaskState.TASK_STATE_WORKING),
+            prev=None,
+            prev_version=v1,
+            context=TEST_CONTEXT,
+        )
+        await store.save(
+            create_task(),
+            event=status_event(state=TaskState.TASK_STATE_COMPLETED),
+            prev=None,
+            prev_version=v2,
+            context=TEST_CONTEXT,
+        )
+
+        await asyncio.wait_for(consumer, timeout=8)
+        assert received == [
+            TaskState.TASK_STATE_WORKING,
+            TaskState.TASK_STATE_COMPLETED,
+        ]
+    finally:
+        await store_engine.dispose()
+        await stream_engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_owner_context_succeeds_on_all_methods(db_url: str) -> None:
+    """The owner's context sees its own events and is accepted everywhere."""
+    task_id = 'task-owner-ctx'
+    store_engine = create_async_engine(db_url)
+    stream_engine = create_async_engine(db_url)
+    _enforce_sqlite_foreign_keys(store_engine)
+    _enforce_sqlite_foreign_keys(stream_engine)
+    try:
+        store = VersionedDatabaseTaskStore(
+            engine=store_engine, create_table=False
+        )
+        stream = DatabaseTaskEventStream(
+            engine=stream_engine,
+            create_table=False,
+            owner_resolver=resolve_user_scope,
+        )
+        await store.initialize()
+        await stream.initialize()
+
+        v1 = await store.save(
+            create_task(task_id),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+        v2 = await store.save(
+            create_task(task_id),
+            event=status_event(task_id, state=TaskState.TASK_STATE_WORKING),
+            prev=None,
+            prev_version=v1,
+            context=TEST_CONTEXT,
+        )
+
+        agen = stream.subscribe(task_id, after=v1, context=TEST_CONTEXT)
+        received = await asyncio.wait_for(agen.__anext__(), timeout=5)
+        assert received.event.status.state == TaskState.TASK_STATE_WORKING
+        await agen.aclose()
+
+        await stream.publish(
+            task_id,
+            VersionedEvent(create_task(task_id), v2),
+            context=TEST_CONTEXT,
+        )
+        await stream.destroy(task_id, context=TEST_CONTEXT)
+    finally:
+        await store_engine.dispose()
+        await stream_engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_other_owner_context_does_not_receive_events(db_url: str) -> None:
+    """A different owner does not see events belonging to another owner."""
+    task_id = 'task-other-owner'
+    store_engine = create_async_engine(db_url)
+    stream_engine = create_async_engine(db_url)
+    _enforce_sqlite_foreign_keys(store_engine)
+    _enforce_sqlite_foreign_keys(stream_engine)
+    try:
+        store = VersionedDatabaseTaskStore(
+            engine=store_engine, create_table=False
+        )
+        stream = DatabaseTaskEventStream(
+            engine=stream_engine,
+            create_table=False,
+            owner_resolver=resolve_user_scope,
+        )
+        await store.initialize()
+        await stream.initialize()
+
+        v1 = await store.save(
+            create_task(task_id),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+        await store.save(
+            create_task(task_id),
+            event=status_event(task_id, state=TaskState.TASK_STATE_WORKING),
+            prev=None,
+            prev_version=v1,
+            context=TEST_CONTEXT,
+        )
+        other = ServerCallContext(user=SampleUser('someone_else'))
+
+        agen = stream.subscribe(task_id, after=v1, context=other)
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(agen.__anext__(), timeout=0.15)
+        await agen.aclose()
+    finally:
+        await store_engine.dispose()
+        await stream_engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_publish_is_noop(db_url: str) -> None:
+    stream_engine = create_async_engine(db_url)
+    try:
+        stream = DatabaseTaskEventStream(
+            engine=stream_engine, create_table=False
+        )
+        await stream.initialize()
+        # publish is a no-op for the DB stream; must not raise.
+        await stream.publish(
+            'task-abc', VersionedEvent(create_task(), TaskVersion(1))
+        )
+        await stream.destroy('task-abc')  # also a no-op
+    finally:
+        await stream_engine.dispose()
diff --git a/tests/server/cluster/test_database_versioned_task_store.py b/tests/server/cluster/test_database_versioned_task_store.py
new file mode 100644
index 000000000..a00dc3612
--- /dev/null
+++ b/tests/server/cluster/test_database_versioned_task_store.py
@@ -0,0 +1,822 @@
+"""Tests for `VersionedDatabaseTaskStore` (CAS over SQLAlchemy)."""
+
+import asyncio
+import os
+
+from collections.abc import AsyncGenerator
+from unittest.mock import patch
+
+import pytest
+import pytest_asyncio
+
+from _pytest.mark.structures import ParameterSet
+
+
+pytest.importorskip('sqlalchemy', reason='Database tests require SQLAlchemy')
+
+from a2a.auth.user import User
+from a2a.server.cluster import (
+    ConcurrentTaskModificationError,
+    TaskVersion,
+    VersionedTaskStore,
+)
+from a2a.server.cluster.database_task_store import VersionedDatabaseTaskStore
+from a2a.server.context import ServerCallContext
+from a2a.server.models import Base
+from a2a.types.a2a_pb2 import (
+    ListTasksRequest,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    create_async_engine,
+)
+
+
+def _enforce_sqlite_foreign_keys(engine: AsyncEngine) -> None:
+    """Make SQLite enforce foreign keys, matching Postgres and MySQL.
+
+    SQLite ignores foreign keys unless asked, so without this a FK bug passes
+    the SQLite tests and only fails against the real engines in CI.
+    """
+    if engine.dialect.name != 'sqlite':
+        return
+
+    @event.listens_for(engine.sync_engine, 'connect')
+    def _set_sqlite_pragma(dbapi_conn, _):  # noqa: ANN001, ANN202
+        dbapi_conn.execute('PRAGMA foreign_keys=ON')
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+
+SQLITE_TEST_DSN = 'sqlite+aiosqlite:///file:testdb_versioned?mode=memory&cache=shared&uri=true'
+POSTGRES_TEST_DSN = os.environ.get('POSTGRES_TEST_DSN')
+MYSQL_TEST_DSN = os.environ.get('MYSQL_TEST_DSN')
+
+DB_CONFIGS: list[ParameterSet | tuple[str | None, str]] = [
+    pytest.param((SQLITE_TEST_DSN, 'sqlite'), id='sqlite')
+]
+
+if POSTGRES_TEST_DSN:
+    DB_CONFIGS.append(
+        pytest.param((POSTGRES_TEST_DSN, 'postgresql'), id='postgresql')
+    )
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'postgresql'),
+            marks=pytest.mark.skip(reason='POSTGRES_TEST_DSN not set'),
+            id='postgresql_skipped',
+        )
+    )
+
+if MYSQL_TEST_DSN:
+    DB_CONFIGS.append(pytest.param((MYSQL_TEST_DSN, 'mysql'), id='mysql'))
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'mysql'),
+            marks=pytest.mark.skip(reason='MYSQL_TEST_DSN not set'),
+            id='mysql_skipped',
+        )
+    )
+
+
+def create_task(
+    task_id: str = 'task-abc',
+    context_id: str = 'session-xyz',
+    state: TaskState = TaskState.TASK_STATE_SUBMITTED,
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=state),
+    )
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def versioned_store(
+    request,
+) -> AsyncGenerator[VersionedDatabaseTaskStore, None]:
+    db_url, dialect_name = request.param
+    if db_url is None:
+        pytest.skip(f'DSN for {dialect_name} not set in environment variables.')
+
+    engine = create_async_engine(db_url)
+    _enforce_sqlite_foreign_keys(engine)
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        store = VersionedDatabaseTaskStore(engine=engine, create_table=False)
+        await store.initialize()
+        yield store
+    finally:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+        await engine.dispose()
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def uninitialized_store(
+    request,
+) -> AsyncGenerator[VersionedDatabaseTaskStore, None]:
+    """A store that creates its tables lazily, without `initialize()`."""
+    db_url, dialect_name = request.param
+    if db_url is None:
+        pytest.skip(f'DSN for {dialect_name} not set in environment variables.')
+    engine = create_async_engine(db_url)
+    _enforce_sqlite_foreign_keys(engine)
+    try:
+        yield VersionedDatabaseTaskStore(engine=engine, create_table=True)
+    finally:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+        await engine.dispose()
+
+
+@pytest.mark.asyncio
+async def test_is_a_versioned_task_store(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    assert isinstance(versioned_store, VersionedTaskStore)
+
+
+@pytest.mark.asyncio
+async def test_as_task_store_exposes_underlying_store(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    from a2a.server.tasks.task_store import TaskStore
+
+    assert isinstance(versioned_store.as_task_store, TaskStore)
+
+
+@pytest.mark.asyncio
+async def test_non_integer_version_on_update_raises_type_error(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    # A string-valued version can't back the integer `version` column.
+    with pytest.raises(TypeError, match='integer versions'):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_WORKING),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion('not-an-int'),
+            context=TEST_CONTEXT,
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_missing_returns_none(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    assert await versioned_store.get('nope', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_first_save_then_get(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    task = create_task()
+    v1 = await versioned_store.save(
+        task,
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    assert not v1.is_missing
+
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task.id == 'task-abc'
+    assert stored.version == v1
+
+
+@pytest.mark.asyncio
+async def test_update_with_matching_version_succeeds(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    v2 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    assert v2.is_after(v1)
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task.status.state == TaskState.TASK_STATE_WORKING
+    assert stored.version == v2
+
+
+@pytest.mark.asyncio
+async def test_stale_update_raises_conflict(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    # Winner advances the task.
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    # Loser still holds v1 -> CAS fails.
+    with pytest.raises(ConcurrentTaskModificationError):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_COMPLETED),
+            event=None,
+            prev=None,
+            prev_version=v1,
+            context=TEST_CONTEXT,
+        )
+    # Store still reflects the winner's write.
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task.status.state == TaskState.TASK_STATE_WORKING
+
+
+@pytest.mark.asyncio
+async def test_concurrent_first_insert_one_wins(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    # First insert succeeds.
+    await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    # A second "first write" (MISSING) for the same id must not silently
+    # clobber; it collides on the primary key -> conflict.
+    with pytest.raises(ConcurrentTaskModificationError):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_WORKING),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+
+
+@pytest.mark.asyncio
+async def test_delete_removes_task(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    assert not v1.is_missing
+    await versioned_store.delete('task-abc', TEST_CONTEXT)
+    assert await versioned_store.get('task-abc', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_list_returns_saved_tasks(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    for i in range(3):
+        await versioned_store.save(
+            create_task(task_id=f'task-{i}'),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+    resp = await versioned_store.list(ListTasksRequest(), TEST_CONTEXT)
+    assert {t.id for t in resp.tasks} == {'task-0', 'task-1', 'task-2'}
+
+
+@pytest.mark.asyncio
+async def test_save_retries_transient_operational_error(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    """A transient OperationalError on write is retried, not surfaced."""
+    from unittest import mock
+
+    from sqlalchemy.exc import OperationalError
+
+    calls = {'n': 0}
+    real_save_once = versioned_store._save_once  # noqa: SLF001
+
+    async def flaky_save_once(*args, **kwargs):  # noqa: ANN002, ANN003
+        calls['n'] += 1
+        if calls['n'] == 1:
+            raise OperationalError('stmt', {}, Exception('database is locked'))
+        return await real_save_once(*args, **kwargs)
+
+    with mock.patch.object(
+        versioned_store, '_save_once', side_effect=flaky_save_once
+    ):
+        version = await versioned_store.save(
+            create_task(),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+    assert calls['n'] == 2  # first failed, second succeeded
+    assert not version.is_missing
+
+
+class _DriverError(Exception):
+    """A driver error carrying a SQLSTATE, as asyncpg errors do."""
+
+    def __init__(self, sqlstate: str) -> None:
+        super().__init__(sqlstate)
+        self.sqlstate = sqlstate
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('sqlstate', 'expected_calls'),
+    [('40P01', 2), ('40001', 2), ('42P01', 1)],
+    ids=['deadlock', 'serialization', 'other'],
+)
+async def test_save_retries_only_transient_postgres_errors(
+    versioned_store: VersionedDatabaseTaskStore,
+    sqlstate: str,
+    expected_calls: int,
+) -> None:
+    """Postgres deadlocks and serialization failures arrive as a plain
+    DBAPIError; they are retried, other DBAPIErrors are not."""
+    from unittest import mock
+
+    from sqlalchemy.exc import DBAPIError
+
+    calls = {'n': 0}
+    real_save_once = versioned_store._save_once  # noqa: SLF001
+
+    async def flaky_save_once(*args, **kwargs):  # noqa: ANN002, ANN003
+        calls['n'] += 1
+        if calls['n'] == 1:
+            raise DBAPIError('stmt', {}, _DriverError(sqlstate))
+        return await real_save_once(*args, **kwargs)
+
+    def save():  # noqa: ANN202
+        return versioned_store.save(
+            create_task(),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+
+    with mock.patch.object(
+        versioned_store, '_save_once', side_effect=flaky_save_once
+    ):
+        if expected_calls == 1:
+            with pytest.raises(DBAPIError):
+                await save()
+        else:
+            await save()
+    assert calls['n'] == expected_calls
+
+
+@pytest.mark.asyncio
+async def test_save_raises_after_exhausting_retries(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    """Persistent OperationalError surfaces after exactly `max_attempts` tries."""
+    from unittest import mock
+
+    from sqlalchemy.exc import OperationalError
+
+    # A store tuned to two attempts with no backoff, so the loop is bounded by
+    # max_attempts (not retries after the first) and the test does not sleep.
+    store = VersionedDatabaseTaskStore(
+        engine=versioned_store._db.engine,  # noqa: SLF001
+        create_table=False,
+        max_attempts=2,
+        retry_delay_s=0.0,
+    )
+
+    calls = {'n': 0}
+
+    async def always_locked(*args, **kwargs):  # noqa: ANN002, ANN003
+        calls['n'] += 1
+        raise OperationalError('stmt', {}, Exception('database is locked'))
+
+    with (
+        mock.patch.object(store, '_save_once', side_effect=always_locked),
+        pytest.raises(OperationalError),
+    ):
+        await store.save(
+            create_task(),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+    assert calls['n'] == 2  # initial try + one retry, then surfaced
+
+
+@pytest.mark.asyncio
+async def test_get_retries_transient_operational_error(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    """A transient OperationalError on read is retried, not surfaced."""
+    from unittest import mock
+
+    from sqlalchemy.exc import OperationalError
+
+    await versioned_store.save(
+        create_task(),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+
+    calls = {'n': 0}
+    real_get_once = versioned_store._get_once  # noqa: SLF001
+
+    async def flaky_get_once(*args, **kwargs):  # noqa: ANN002, ANN003
+        calls['n'] += 1
+        if calls['n'] == 1:
+            raise OperationalError('stmt', {}, Exception('database is locked'))
+        return await real_get_once(*args, **kwargs)
+
+    with mock.patch.object(
+        versioned_store, '_get_once', side_effect=flaky_get_once
+    ):
+        stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert calls['n'] == 2
+    assert stored is not None
+    assert not stored.version.is_missing
+
+
+@pytest.mark.asyncio
+async def test_get_raises_after_exhausting_retries(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    """Read surfaces the error after exactly `max_attempts` tries."""
+    from unittest import mock
+
+    from sqlalchemy.exc import OperationalError
+
+    # As with the write path, bound the read loop to two attempts with no
+    # backoff so the count is asserted and no real sleep occurs.
+    store = VersionedDatabaseTaskStore(
+        engine=versioned_store._db.engine,  # noqa: SLF001
+        create_table=False,
+        max_attempts=2,
+        retry_delay_s=0.0,
+    )
+
+    calls = {'n': 0}
+
+    async def always_locked(*args, **kwargs):  # noqa: ANN002, ANN003
+        calls['n'] += 1
+        raise OperationalError('stmt', {}, Exception('database is locked'))
+
+    with (
+        mock.patch.object(store, '_get_once', side_effect=always_locked),
+        pytest.raises(OperationalError),
+    ):
+        await store.get('task-abc', TEST_CONTEXT)
+    assert calls['n'] == 2  # initial try + one retry, then surfaced
+
+
+@pytest.mark.asyncio
+async def test_retry_defaults(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    """The shipped retry budget defaults are 5 attempts / 0.02s backoff."""
+    assert versioned_store._max_attempts == 5  # noqa: SLF001
+    assert versioned_store._retry_delay_s == 0.02  # noqa: SLF001
+
+
+@pytest.mark.asyncio
+async def test_cancel_overwrites_without_version_match(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_CANCELED),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task.status.state == TaskState.TASK_STATE_CANCELED
+
+
+@pytest.mark.asyncio
+async def test_cancel_on_terminal_task_raises(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_COMPLETED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    with pytest.raises(ConcurrentTaskModificationError):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_CANCELED),
+            event=None,
+            prev=None,
+            prev_version=v1,
+            context=TEST_CONTEXT,
+        )
+
+
+@pytest.mark.asyncio
+async def test_cancel_absent_task_raises(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    with pytest.raises(ConcurrentTaskModificationError):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_CANCELED),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion(123),
+            context=TEST_CONTEXT,
+        )
+
+
+@pytest.mark.asyncio
+async def test_adopts_task_written_by_plain_store(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    # A task row with no version side-table row (e.g. written by the plain
+    # store) reads back as MISSING and is adopted on the next versioned save.
+    await versioned_store.as_task_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED), TEST_CONTEXT
+    )
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.version.is_missing
+
+    v1 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    adopted = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert adopted is not None
+    assert not adopted.version.is_missing
+    assert adopted.version == v1
+
+
+@pytest.mark.asyncio
+async def test_concurrent_first_writer_conflicts(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    with pytest.raises(ConcurrentTaskModificationError):
+        await versioned_store.save(
+            create_task(state=TaskState.TASK_STATE_SUBMITTED),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+
+
+@pytest.mark.asyncio
+async def test_delete_removes_version_row(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    await versioned_store.delete('task-abc', TEST_CONTEXT)
+    assert await versioned_store.get('task-abc', TEST_CONTEXT) is None
+
+    # A fresh first write succeeds only if the old version row is gone.
+    await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+
+
+@pytest.mark.asyncio
+async def test_get_without_initialize_creates_tables(
+    uninitialized_store: VersionedDatabaseTaskStore,
+) -> None:
+    assert await uninitialized_store.get('task-abc', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_delete_without_initialize_creates_tables(
+    uninitialized_store: VersionedDatabaseTaskStore,
+) -> None:
+    await uninitialized_store.delete('task-abc', TEST_CONTEXT)
+    assert await uninitialized_store.get('task-abc', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_versions_count_writes(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    v1 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_SUBMITTED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    v2 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    # Cancel skips the version check but still counts as a write.
+    v3 = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_CANCELED),
+        event=None,
+        prev=None,
+        prev_version=v1,
+        context=TEST_CONTEXT,
+    )
+    assert (v1, v2, v3) == (TaskVersion(1), TaskVersion(2), TaskVersion(3))
+    stored = await versioned_store.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.version == v3
+
+
+@pytest.mark.asyncio
+async def test_cancel_of_adopted_task_starts_at_version_one(
+    versioned_store: VersionedDatabaseTaskStore,
+) -> None:
+    await versioned_store.as_task_store.save(
+        create_task(state=TaskState.TASK_STATE_WORKING), TEST_CONTEXT
+    )
+    version = await versioned_store.save(
+        create_task(state=TaskState.TASK_STATE_CANCELED),
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    assert version == TaskVersion(1)
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(20)
+@pytest.mark.parametrize('db_config', DB_CONFIGS)
+async def test_cancel_racing_save_does_not_deadlock(
+    db_config: tuple[str | None, str],
+) -> None:
+    """A cancel that starts while another replica's save holds the version
+    row waits for it instead of deadlocking on the tasks row."""
+    db_url, dialect_name = db_config
+    if db_url is None:
+        pytest.skip(f'DSN for {dialect_name} not set in environment variables.')
+    if dialect_name == 'sqlite':
+        pytest.skip('SQLite has no row locks.')
+
+    engine_a = create_async_engine(db_url)
+    engine_b = create_async_engine(db_url)
+    try:
+        async with engine_a.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        store_a = VersionedDatabaseTaskStore(
+            engine=engine_a, create_table=False
+        )
+        store_b = VersionedDatabaseTaskStore(
+            engine=engine_b, create_table=False
+        )
+        v1 = await store_a.save(
+            create_task(state=TaskState.TASK_STATE_WORKING),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+
+        # Pause A's save after it has locked the version row and before it
+        # writes the tasks row; B's cancel starts in that window.
+        a_holds_version = asyncio.Event()
+        resume_a = asyncio.Event()
+        real_merge = AsyncSession.merge
+
+        async def paused_merge(self, *args, **kwargs):  # noqa: ANN001, ANN002, ANN003, ANN202
+            if self.bind is engine_a and not a_holds_version.is_set():
+                a_holds_version.set()
+                await resume_a.wait()
+            return await real_merge(self, *args, **kwargs)
+
+        async def complete_on_a() -> TaskVersion:
+            return await store_a.save(
+                create_task(state=TaskState.TASK_STATE_COMPLETED),
+                event=None,
+                prev=None,
+                prev_version=v1,
+                context=TEST_CONTEXT,
+            )
+
+        async def cancel_on_b() -> TaskVersion:
+            await a_holds_version.wait()
+            return await store_b.save(
+                create_task(state=TaskState.TASK_STATE_CANCELED),
+                event=None,
+                prev=None,
+                prev_version=v1,
+                context=TEST_CONTEXT,
+            )
+
+        with patch.object(AsyncSession, 'merge', paused_merge):
+            both = asyncio.gather(
+                complete_on_a(), cancel_on_b(), return_exceptions=True
+            )
+            await a_holds_version.wait()
+            await asyncio.sleep(0.3)  # let B reach its first lock
+            resume_a.set()
+            save_result, cancel_result = await both
+
+        assert save_result == TaskVersion(2)
+        # B waited for A, then found the task already terminal.
+        assert isinstance(cancel_result, ConcurrentTaskModificationError)
+        final = await store_a.get('task-abc', TEST_CONTEXT)
+        assert final is not None
+        assert final.task.status.state == TaskState.TASK_STATE_COMPLETED
+    finally:
+        async with engine_a.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+        await engine_a.dispose()
+        await engine_b.dispose()
diff --git a/tests/server/cluster/test_handler_wiring.py b/tests/server/cluster/test_handler_wiring.py
new file mode 100644
index 000000000..8451aad98
--- /dev/null
+++ b/tests/server/cluster/test_handler_wiring.py
@@ -0,0 +1,165 @@
+import pytest
+
+from a2a.server.agent_execution.agent_executor import AgentExecutor
+from a2a.server.cluster import (
+    LegacyTaskStoreAdapter,
+    TaskEventStream,
+)
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.request_handlers.default_request_handler_v2 import (
+    DefaultRequestHandlerV2,
+)
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types.a2a_pb2 import AgentCard
+
+from .conftest import (
+    InMemoryTaskEventStream,
+    VersionedInMemoryTaskStore,
+    make_context,
+)
+
+
+class NoopExecutor(AgentExecutor):
+    async def execute(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+    async def cancel(self, context, event_queue) -> None:  # noqa: ANN001
+        pass
+
+
+def make_handler(event_stream: TaskEventStream | None = None):
+    return DefaultRequestHandlerV2(
+        agent_executor=NoopExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=AgentCard(),
+        event_stream=event_stream,
+    )
+
+
+def test_plain_store_kept_as_is_and_adapted_for_versioned() -> None:
+    # A plain TaskStore is exposed unchanged as `task_store`; internal cluster
+    # code sees it wrapped in a LegacyTaskStoreAdapter.
+    store = InMemoryTaskStore()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=NoopExecutor(),
+        task_store=store,
+        agent_card=AgentCard(),
+    )
+    assert handler.task_store is store
+    assert isinstance(handler._versioned_store, LegacyTaskStoreAdapter)  # noqa: SLF001
+    assert handler._versioned_store.store is store  # noqa: SLF001
+
+
+def test_versioned_store_used_directly_and_not_swapped() -> None:
+    # LegacyTaskStoreAdapter is itself a VersionedTaskStore, so this asserts the
+    # no-swap contract without a test double.
+    store = LegacyTaskStoreAdapter(InMemoryTaskStore())
+    handler = DefaultRequestHandlerV2(
+        agent_executor=NoopExecutor(),
+        task_store=store,
+        agent_card=AgentCard(),
+    )
+    assert handler.task_store is store
+    assert handler._versioned_store is store  # noqa: SLF001
+
+
+def test_default_handler_has_no_stream() -> None:
+    # No stream supplied: single-process mode, the handler holds no event stream.
+    handler = make_handler()
+    assert handler._event_stream is None  # noqa: SLF001
+
+
+def test_explicit_stream_is_stored() -> None:
+    stream = InMemoryTaskEventStream()
+    handler = make_handler(event_stream=stream)
+    assert handler._event_stream is stream  # noqa: SLF001
+
+
+def test_stream_is_threaded_to_registry() -> None:
+    stream = InMemoryTaskEventStream()
+    handler = make_handler(event_stream=stream)
+    assert handler._active_task_registry._event_stream is stream  # noqa: SLF001
+
+
+def test_default_alias_accepts_event_stream() -> None:
+    # DefaultRequestHandler is an alias for v2; ensure the kwarg flows through.
+    stream = InMemoryTaskEventStream()
+    handler = DefaultRequestHandler(
+        NoopExecutor(),
+        InMemoryTaskStore(),
+        AgentCard(),
+        event_stream=stream,
+    )
+    assert handler._event_stream is stream  # noqa: SLF001
+
+
+@pytest.mark.asyncio
+async def test_active_task_receives_stream_from_registry() -> None:
+    stream = InMemoryTaskEventStream()
+    handler = make_handler(event_stream=stream)
+    context = make_context()
+
+    active_task = await handler._active_task_registry.get_or_create(  # noqa: SLF001
+        'task-1',
+        call_context=context,
+        create_task_if_missing=True,
+        initial_message=None,
+    )
+    try:
+        assert active_task._event_stream is stream  # noqa: SLF001
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_none_event_stream_propagates_none_to_active_task() -> None:
+    # When no stream is passed, the ActiveTask receives None and uses only its
+    # in-process queues (single-process behaviour).
+    handler = make_handler(event_stream=None)
+    context = make_context()
+    active_task = await handler._active_task_registry.get_or_create(  # noqa: SLF001
+        'task-1',
+        call_context=context,
+        create_task_if_missing=True,
+        initial_message=None,
+    )
+    try:
+        assert active_task._event_stream is None  # noqa: SLF001
+    finally:
+        await handler.aclose()
+
+
+def test_versioned_store_without_stream_warns() -> None:
+    # A versioned store signals cluster intent; without a shared stream,
+    # cross-replica streaming is disabled, so construction warns once.
+    with pytest.warns(UserWarning, match='cross-replica streaming is disabled'):
+        DefaultRequestHandlerV2(
+            agent_executor=NoopExecutor(),
+            task_store=VersionedInMemoryTaskStore(),
+            agent_card=AgentCard(),
+        )
+
+
+def test_versioned_store_with_stream_does_not_warn(recwarn) -> None:  # noqa: ANN001
+    # Supplying a shared stream is the multi-replica configuration: no warning.
+    DefaultRequestHandlerV2(
+        agent_executor=NoopExecutor(),
+        task_store=VersionedInMemoryTaskStore(),
+        agent_card=AgentCard(),
+        event_stream=InMemoryTaskEventStream(),
+    )
+    assert not [
+        w
+        for w in recwarn
+        if 'cross-replica streaming is disabled' in str(w.message)
+    ]
+
+
+def test_plain_store_without_stream_does_not_warn(recwarn) -> None:  # noqa: ANN001
+    # A plain store is the single-process default: no cluster intent, no warning.
+    make_handler()
+    assert not [
+        w
+        for w in recwarn
+        if 'cross-replica streaming is disabled' in str(w.message)
+    ]
diff --git a/tests/server/cluster/test_send_multireplica.py b/tests/server/cluster/test_send_multireplica.py
new file mode 100644
index 000000000..fabd02dca
--- /dev/null
+++ b/tests/server/cluster/test_send_multireplica.py
@@ -0,0 +1,169 @@
+import asyncio
+
+import pytest
+
+from a2a.server.cluster import ConcurrentTaskModificationError, TaskVersion
+from a2a.types.a2a_pb2 import Role, Task, TaskState
+from a2a.utils.errors import InternalError
+
+from .conftest import (
+    CompletingAgent,
+    InputRequiredThenCompleteAgent,
+    VersionedInMemoryTaskStore,
+    build_send_request,
+    make_replica,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_single_send_completes_on_shared_store(
+    shared_store, shared_stream, context
+) -> None:
+    handler = make_replica(shared_store, shared_stream, CompletingAgent())
+    try:
+        result = await handler.on_message_send(
+            build_send_request('hi'), context
+        )
+        assert result.status.state == TaskState.TASK_STATE_COMPLETED
+        # Task persisted with a real version.
+        stored = await shared_store.get(result.id, context)
+        assert stored is not None
+        assert stored.task.status.state == TaskState.TASK_STATE_COMPLETED
+        assert not stored.version.is_missing
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(15)
+async def test_multiturn_input_required_across_replicas(
+    shared_store, shared_stream, context
+) -> None:
+    """turn 1 -> replica A, turn 2 -> replica B, turn 3 -> replica A.
+
+    The pre-fix bug: replica A reuses a stale cached snapshot on turn 3 and
+    clobbers replica B's turn-2 write. With request-boundary invalidation +
+    CAS, A re-reads and the task advances correctly.
+    """
+    agent = InputRequiredThenCompleteAgent()
+    replica_a = make_replica(shared_store, shared_stream, agent)
+    replica_b = make_replica(shared_store, shared_stream, agent)
+    try:
+        # Turn 1 on A: creates task, asks for input.
+        r1 = await replica_a.on_message_send(
+            build_send_request('q1', message_id='m1'), context
+        )
+        assert r1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        task_id = r1.id
+        context_id = r1.context_id
+
+        # Turn 2 on B: provides input; agent still needs more (2 user msgs).
+        r2 = await replica_b.on_message_send(
+            build_send_request(
+                'a1', task_id=task_id, context_id=context_id, message_id='m2'
+            ),
+            context,
+        )
+        assert r2.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        # B's write is durable and visible.
+        stored = await shared_store.get(task_id, context)
+        assert stored is not None
+        assert (
+            sum(1 for m in stored.task.history if m.role == Role.ROLE_USER) == 2
+        )
+
+        # Turn 3 back on A: must see B's state (not the stale turn-1 snapshot)
+        # and complete.
+        r3 = await replica_a.on_message_send(
+            build_send_request(
+                'a2', task_id=task_id, context_id=context_id, message_id='m3'
+            ),
+            context,
+        )
+        assert r3.status.state == TaskState.TASK_STATE_COMPLETED
+    finally:
+        await replica_a.aclose()
+        await replica_b.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_stale_version_save_raises_conflict_directly(
+    shared_store, shared_stream, context
+) -> None:
+    """The store-level CAS that underpins the handler fix."""
+    handler = make_replica(shared_store, shared_stream, CompletingAgent())
+    try:
+        result = await handler.on_message_send(
+            build_send_request('hi'), context
+        )
+        stored = await shared_store.get(result.id, context)
+        assert stored is not None
+        task, v = stored.task, stored.version
+        # Simulate a stale writer: another write advances the version.
+        await shared_store.save(
+            task, event=None, prev=None, prev_version=v, context=context
+        )
+        # Now the original version is stale.
+        with pytest.raises(ConcurrentTaskModificationError):
+            await shared_store.save(
+                task, event=None, prev=None, prev_version=v, context=context
+            )
+    finally:
+        await handler.aclose()
+
+
+class _ContendedStore(VersionedInMemoryTaskStore):
+    """Rejects every save while `contended` is set, as if other replicas kept
+    writing the task."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.contended = False
+
+    async def save(self, task: Task, **kwargs) -> TaskVersion:  # noqa: ANN003
+        if self.contended:
+            raise ConcurrentTaskModificationError(task.id)
+        return await super().save(task, **kwargs)
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_follow_up_that_keeps_conflicting_fails_with_a2a_error(
+    shared_stream, context
+) -> None:
+    """When the retry after a conflict conflicts again, the request fails
+    with an A2A error instead of hanging, and the stored task is kept."""
+    store = _ContendedStore()
+    handler = make_replica(
+        store, shared_stream, InputRequiredThenCompleteAgent()
+    )
+    try:
+        r1 = await handler.on_message_send(
+            build_send_request('q1', message_id='m1'), context
+        )
+        assert r1.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+        store.contended = True
+        with pytest.raises(InternalError):
+            await asyncio.wait_for(
+                handler.on_message_send(
+                    build_send_request(
+                        'a',
+                        task_id=r1.id,
+                        context_id=r1.context_id,
+                        message_id='m2',
+                    ),
+                    context,
+                ),
+                timeout=5,
+            )
+        store.contended = False
+
+        stored = await store.get(r1.id, context)
+        assert stored is not None
+        assert stored.task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    finally:
+        store.contended = False
+        await handler.aclose()
diff --git a/tests/server/cluster/test_subscribe_multireplica.py b/tests/server/cluster/test_subscribe_multireplica.py
new file mode 100644
index 000000000..4cc04c8bb
--- /dev/null
+++ b/tests/server/cluster/test_subscribe_multireplica.py
@@ -0,0 +1,139 @@
+import asyncio
+
+import pytest
+
+from a2a.types.a2a_pb2 import SubscribeToTaskRequest, TaskState
+from a2a.utils.errors import TaskNotFoundError, UnsupportedOperationError
+
+from .conftest import (
+    ControlledAgent,
+    build_send_request,
+    make_context,
+    make_replica,
+    wait_for_state,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(15)
+async def test_resubscribe_on_non_owning_replica_streams_events(
+    shared_store, shared_stream, context
+) -> None:
+    """Replica A runs the agent; a resubscribe on replica B streams its events.
+
+    Pre-fix, B would build a local ActiveTask, emit the snapshot, then hang.
+    """
+    agent = ControlledAgent()
+    replica_a = make_replica(shared_store, shared_stream, agent)
+    replica_b = make_replica(shared_store, shared_stream, agent)
+    try:
+        a_events: list = []
+
+        async def run_a() -> None:
+            async for ev in replica_a.on_message_send_stream(
+                build_send_request('go', message_id='m1'), context
+            ):
+                a_events.append(ev)
+
+        a_task = asyncio.create_task(run_a())
+        await asyncio.wait_for(agent.working.wait(), timeout=5)
+
+        task_id = next(
+            iter(replica_a._active_task_registry._active_tasks)  # noqa: SLF001
+        )
+        await wait_for_state(
+            shared_store, task_id, TaskState.TASK_STATE_WORKING, context
+        )
+
+        # Resubscribe on B (not running the agent). Collect until COMPLETED.
+        b_states: list = []
+
+        async def run_b() -> None:
+            async for ev in replica_b.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=task_id), context
+            ):
+                if getattr(ev, 'status', None):
+                    b_states.append(ev.status.state)
+                    if ev.status.state == TaskState.TASK_STATE_COMPLETED:
+                        return
+
+        b_task = asyncio.create_task(run_b())
+        await asyncio.sleep(0.1)  # let B read snapshot + start tailing
+
+        # Release the agent on A -> it completes; B must observe via the stream.
+        agent.release.set()
+
+        await asyncio.wait_for(b_task, timeout=8)
+        await asyncio.wait_for(a_task, timeout=8)
+
+        assert b_states[0] == TaskState.TASK_STATE_WORKING
+        assert b_states[-1] == TaskState.TASK_STATE_COMPLETED
+    finally:
+        await replica_a.aclose()
+        await replica_b.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_resubscribe_to_terminal_task_rejected(
+    shared_store, shared_stream, context
+) -> None:
+    """A resubscribe to an already-finished task is rejected (no hang)."""
+    agent = ControlledAgent()
+    agent.release.set()  # completes immediately
+    handler = make_replica(shared_store, shared_stream, agent)
+    other = make_replica(shared_store, shared_stream, agent)
+    try:
+        result = await handler.on_message_send(
+            build_send_request('go', message_id='m1'), context
+        )
+        assert result.status.state == TaskState.TASK_STATE_COMPLETED
+        task_id = result.id
+
+        # Terminal task: the non-owning replica rejects rather than hanging.
+        with pytest.raises(UnsupportedOperationError, match='terminal state'):
+            async for _ in other.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=task_id), context
+            ):
+                pass
+    finally:
+        await handler.aclose()
+        await other.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_resubscribe_absent_task_raises_not_found(
+    shared_store, shared_stream, context
+) -> None:
+    handler = make_replica(shared_store, shared_stream, ControlledAgent())
+    try:
+        with pytest.raises(TaskNotFoundError):
+            async for _ in handler.on_subscribe_to_task(
+                SubscribeToTaskRequest(id='nope'), context
+            ):
+                pass
+    finally:
+        await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(10)
+async def test_resubscribe_non_owner_rejected(
+    shared_store, shared_stream
+) -> None:
+    """Issue #1159: a non-owner cannot resubscribe to another user's task."""
+    agent = ControlledAgent()
+    agent.release.set()
+    handler = make_replica(shared_store, shared_stream, agent)
+    try:
+        result = await handler.on_message_send(
+            build_send_request('go', message_id='m1'), make_context('alice')
+        )
+        with pytest.raises(TaskNotFoundError):
+            async for _ in handler.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=result.id), make_context('bob')
+            ):
+                pass
+    finally:
+        await handler.aclose()
diff --git a/tests/server/cluster/test_task_store_adapter.py b/tests/server/cluster/test_task_store_adapter.py
new file mode 100644
index 000000000..3124c0879
--- /dev/null
+++ b/tests/server/cluster/test_task_store_adapter.py
@@ -0,0 +1,165 @@
+"""Tests for `LegacyTaskStoreAdapter` and the `VersionedTaskStore` contract."""
+
+import pytest
+
+from a2a.auth.user import User
+from a2a.server.cluster import (
+    ConcurrentTaskModificationError,
+    LegacyTaskStoreAdapter,
+    TaskVersion,
+    VersionedTaskStore,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types.a2a_pb2 import (
+    ListTasksRequest,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+
+def create_minimal_task(
+    task_id: str = 'task-abc', context_id: str = 'session-xyz'
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+
+def make_adapter() -> LegacyTaskStoreAdapter:
+    return LegacyTaskStoreAdapter(InMemoryTaskStore())
+
+
+def test_concurrent_modification_error_carries_task_id() -> None:
+    err = ConcurrentTaskModificationError('task-abc')
+    assert err.task_id == 'task-abc'
+    assert 'task-abc' in str(err)
+    assert isinstance(err, Exception)
+
+
+def test_adapter_is_a_versioned_task_store() -> None:
+    assert isinstance(make_adapter(), VersionedTaskStore)
+
+
+def test_store_property_exposes_wrapped_store() -> None:
+    store = InMemoryTaskStore()
+    adapter = LegacyTaskStoreAdapter(store)
+    assert adapter.store is store
+
+
+@pytest.mark.asyncio
+async def test_save_returns_missing_version() -> None:
+    adapter = make_adapter()
+    task = create_minimal_task()
+    version = await adapter.save(
+        task,
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    assert version.is_missing
+
+
+@pytest.mark.asyncio
+async def test_get_returns_task_and_missing_version() -> None:
+    adapter = make_adapter()
+    task = create_minimal_task()
+    await adapter.save(
+        task,
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+
+    stored = await adapter.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task == task
+    assert stored.version.is_missing
+
+
+@pytest.mark.asyncio
+async def test_get_missing_task_returns_none() -> None:
+    adapter = make_adapter()
+    assert await adapter.get('does-not-exist', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_save_never_raises_on_stale_prev_version() -> None:
+    # An unversioned store performs no CAS: a "stale" prev_version is ignored
+    # and the write succeeds (last-writer-wins), matching today's behaviour.
+    adapter = make_adapter()
+    task = create_minimal_task()
+    await adapter.save(
+        task,
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    # Save again with a deliberately non-matching, non-missing prev_version.
+    updated = create_minimal_task()
+    updated.status.state = TaskState.TASK_STATE_WORKING
+    version = await adapter.save(
+        updated,
+        event=None,
+        prev=task,
+        prev_version=TaskVersion(999),
+        context=TEST_CONTEXT,
+    )
+    assert version.is_missing
+    stored = await adapter.get('task-abc', TEST_CONTEXT)
+    assert stored is not None
+    assert stored.task.status.state == TaskState.TASK_STATE_WORKING
+
+
+@pytest.mark.asyncio
+async def test_delete_delegates_to_inner() -> None:
+    adapter = make_adapter()
+    task = create_minimal_task()
+    await adapter.save(
+        task,
+        event=None,
+        prev=None,
+        prev_version=TaskVersion.MISSING,
+        context=TEST_CONTEXT,
+    )
+    await adapter.delete('task-abc', TEST_CONTEXT)
+    assert await adapter.get('task-abc', TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_list_delegates_to_inner() -> None:
+    adapter = make_adapter()
+    for i in range(3):
+        await adapter.save(
+            create_minimal_task(task_id=f'task-{i}'),
+            event=None,
+            prev=None,
+            prev_version=TaskVersion.MISSING,
+            context=TEST_CONTEXT,
+        )
+    response = await adapter.list(ListTasksRequest(), TEST_CONTEXT)
+    assert {t.id for t in response.tasks} == {'task-0', 'task-1', 'task-2'}
diff --git a/tests/server/cluster/test_version.py b/tests/server/cluster/test_version.py
new file mode 100644
index 000000000..65bc0e67a
--- /dev/null
+++ b/tests/server/cluster/test_version.py
@@ -0,0 +1,102 @@
+"""Tests for `TaskVersion`."""
+
+import pytest
+
+from a2a.server.cluster import TaskVersion
+
+
+def test_missing_is_missing() -> None:
+    assert TaskVersion.MISSING.is_missing is True
+
+
+def test_real_version_is_not_missing() -> None:
+    assert TaskVersion(1).is_missing is False
+    assert TaskVersion('etag-abc').is_missing is False
+
+
+def test_zero_int_is_missing() -> None:
+    # 0 is the reserved "not tracked" value.
+    assert TaskVersion(0).is_missing is True
+    assert TaskVersion(0) == TaskVersion.MISSING
+
+
+def test_string_zero_is_not_missing() -> None:
+    # '0' != 0 in Python, so a string ETag of '0' is a real version.
+    assert TaskVersion('0').is_missing is False
+
+
+def test_equality_by_value() -> None:
+    assert TaskVersion(5) == TaskVersion(5)
+    assert TaskVersion(5) != TaskVersion(6)
+    assert TaskVersion('a') == TaskVersion('a')
+    assert TaskVersion('a') != TaskVersion('b')
+
+
+def test_equality_with_non_taskversion() -> None:
+    assert TaskVersion(5) != 5
+    assert TaskVersion(5) != 'TaskVersion(5)'
+    assert (TaskVersion(5) == object()) is False
+
+
+def test_hashable_and_usable_in_sets_and_dicts() -> None:
+    versions = {TaskVersion(1), TaskVersion(1), TaskVersion(2)}
+    assert versions == {TaskVersion(1), TaskVersion(2)}
+
+    mapping = {TaskVersion('x'): 'value'}
+    assert mapping[TaskVersion('x')] == 'value'
+
+
+def test_repr() -> None:
+    assert repr(TaskVersion.MISSING) == 'TaskVersion.MISSING'
+    assert repr(TaskVersion(0)) == 'TaskVersion.MISSING'
+    assert repr(TaskVersion(7)) == 'TaskVersion(7)'
+    assert repr(TaskVersion('etag')) == "TaskVersion('etag')"
+
+
+def test_is_after_ordering_integers() -> None:
+    assert TaskVersion(2).is_after(TaskVersion(1)) is True
+    assert TaskVersion(1).is_after(TaskVersion(2)) is False
+
+
+def test_is_after_equal_versions_is_false() -> None:
+    # "strictly later" -> equal is not after.
+    assert TaskVersion(1).is_after(TaskVersion(1)) is False
+
+
+def test_is_after_missing_asymmetry() -> None:
+    # Anything real is "after" MISSING (untracked baseline is oldest).
+    assert TaskVersion(1).is_after(TaskVersion.MISSING) is True
+    # MISSING is never after a real version.
+    assert TaskVersion.MISSING.is_after(TaskVersion(1)) is False
+
+
+def test_is_after_both_missing_is_false() -> None:
+    # other.is_missing short-circuits to True per the contract.
+    assert TaskVersion.MISSING.is_after(TaskVersion.MISSING) is True
+
+
+def test_is_after_string_versions() -> None:
+    # Works for orderable non-int values too (e.g. zero-padded ETags).
+    assert TaskVersion('0002').is_after(TaskVersion('0001')) is True
+    assert TaskVersion('0001').is_after(TaskVersion('0002')) is False
+
+
+def test_missing_is_a_singleton_value() -> None:
+    # Not necessarily the same object, but value-equal and both missing.
+    assert TaskVersion(0) == TaskVersion.MISSING
+    assert TaskVersion(0).is_missing and TaskVersion.MISSING.is_missing
+
+
+def test_is_after_mismatched_value_types_raises() -> None:
+    # A store uses one value type consistently; comparing an int-backed
+    # version against a str-backed one is a programming error.
+    with pytest.raises(TypeError, match='different value types'):
+        TaskVersion(1).is_after(TaskVersion('a'))
+    with pytest.raises(TypeError, match='different value types'):
+        TaskVersion('a').is_after(TaskVersion(1))
+
+
+def test_is_after_mismatch_guard_not_triggered_when_either_missing() -> None:
+    # MISSING short-circuits before the type check, so no TypeError.
+    assert TaskVersion('a').is_after(TaskVersion.MISSING) is True
+    assert TaskVersion.MISSING.is_after(TaskVersion(1)) is False
diff --git a/tests/server/events/__init__.py b/tests/server/events/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/events/test_event_consumer.py b/tests/server/events/test_event_consumer.py
index 56db30a18..fb0f878a1 100644
--- a/tests/server/events/test_event_consumer.py
+++ b/tests/server/events/test_event_consumer.py
@@ -1,113 +1,66 @@
 import asyncio
 
 from typing import Any
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
 from a2a.server.events.event_consumer import EventConsumer
-from a2a.server.events.event_queue import EventQueue
-from a2a.types import (
-    A2AError,
+from a2a.server.events.event_queue import (
+    EventQueue,
+    EventQueueLegacy,
+    QueueShutDown,
+)
+from a2a.types.a2a_pb2 import (
     Artifact,
-    InternalError,
-    JSONRPCError,
     Message,
     Part,
+    Role,
     Task,
     TaskArtifactUpdateEvent,
     TaskState,
     TaskStatus,
     TaskStatusUpdateEvent,
-    TextPart,
 )
-from a2a.utils.errors import ServerError
+from pydantic import ValidationError
+
 
+def create_sample_message(message_id: str = '111') -> Message:
+    """Create a sample Message proto object."""
+    return Message(
+        message_id=message_id,
+        role=Role.ROLE_AGENT,
+        parts=[Part(text='test message')],
+    )
 
-MINIMAL_TASK: dict[str, Any] = {
-    'id': '123',
-    'contextId': 'session-xyz',
-    'status': {'state': 'submitted'},
-    'type': 'task',
-}
 
-MESSAGE_PAYLOAD: dict[str, Any] = {
-    'role': 'agent',
-    'parts': [{'text': 'test message'}],
-    'messageId': '111',
-}
+def create_sample_task(
+    task_id: str = '123', context_id: str = 'session-xyz'
+) -> Task:
+    """Create a sample Task proto object."""
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
 
 
 @pytest.fixture
 def mock_event_queue():
-    return AsyncMock(spec=EventQueue)
+    return AsyncMock(spec=EventQueueLegacy)
 
 
 @pytest.fixture
-def event_consumer(mock_event_queue: EventQueue):
+def event_consumer(mock_event_queue: EventQueueLegacy):
     return EventConsumer(queue=mock_event_queue)
 
 
-@pytest.mark.asyncio
-async def test_consume_one_task_event(
-    event_consumer: MagicMock,
-    mock_event_queue: MagicMock,
-):
-    task_event = Task(**MINIMAL_TASK)
-    mock_event_queue.dequeue_event.return_value = task_event
-    result = await event_consumer.consume_one()
-    assert result == task_event
-    mock_event_queue.task_done.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_consume_one_message_event(
-    event_consumer: MagicMock,
-    mock_event_queue: MagicMock,
-):
-    message_event = Message(**MESSAGE_PAYLOAD)
-    mock_event_queue.dequeue_event.return_value = message_event
-    result = await event_consumer.consume_one()
-    assert result == message_event
-    mock_event_queue.task_done.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_consume_one_a2a_error_event(
-    event_consumer: MagicMock,
-    mock_event_queue: MagicMock,
-):
-    error_event = A2AError(InternalError())
-    mock_event_queue.dequeue_event.return_value = error_event
-    result = await event_consumer.consume_one()
-    assert result == error_event
-    mock_event_queue.task_done.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_consume_one_jsonrpc_error_event(
-    event_consumer: MagicMock,
-    mock_event_queue: MagicMock,
-):
-    error_event = JSONRPCError(code=123, message='Some Error')
-    mock_event_queue.dequeue_event.return_value = error_event
-    result = await event_consumer.consume_one()
-    assert result == error_event
-    mock_event_queue.task_done.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_consume_one_queue_empty(
-    event_consumer: MagicMock,
-    mock_event_queue: MagicMock,
-):
-    mock_event_queue.dequeue_event.side_effect = asyncio.QueueEmpty
-    try:
-        result = await event_consumer.consume_one()
-        assert result is not None
-    except ServerError:
-        pass
-    mock_event_queue.task_done.assert_not_called()
+def test_init_logs_debug_message(mock_event_queue: EventQueue):
+    """Test that __init__ logs a debug message."""
+    # Patch the logger instance within the module where EventConsumer is defined
+    with patch('a2a.server.events.event_consumer.logger') as mock_logger:
+        EventConsumer(queue=mock_event_queue)  # Instantiate to trigger __init__
+        mock_logger.debug.assert_called_once_with('EventConsumer initialized')
 
 
 @pytest.mark.asyncio
@@ -116,19 +69,16 @@ async def test_consume_all_multiple_events(
     mock_event_queue: MagicMock,
 ):
     events: list[Any] = [
-        Task(**MINIMAL_TASK),
+        create_sample_task(),
         TaskArtifactUpdateEvent(
-            taskId='task_123',
-            contextId='session-xyz',
-            artifact=Artifact(
-                artifactId='11', parts=[Part(TextPart(text='text'))]
-            ),
+            task_id='task_123',
+            context_id='session-xyz',
+            artifact=Artifact(artifact_id='11', parts=[Part(text='text')]),
         ),
         TaskStatusUpdateEvent(
-            taskId='task_123',
-            contextId='session-xyz',
-            status=TaskStatus(state=TaskState.working),
-            final=True,
+            task_id='task_123',
+            context_id='session-xyz',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
         ),
     ]
     cursor = 0
@@ -139,6 +89,8 @@ async def mock_dequeue() -> Any:
             event = events[cursor]
             cursor += 1
             return event
+        mock_event_queue.is_closed.return_value = True
+        raise asyncio.QueueEmpty()
 
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
@@ -157,20 +109,17 @@ async def test_consume_until_message(
     mock_event_queue: MagicMock,
 ):
     events: list[Any] = [
-        Task(**MINIMAL_TASK),
+        create_sample_task(),
         TaskArtifactUpdateEvent(
-            taskId='task_123',
-            contextId='session-xyz',
-            artifact=Artifact(
-                artifactId='11', parts=[Part(TextPart(text='text'))]
-            ),
+            task_id='task_123',
+            context_id='session-xyz',
+            artifact=Artifact(artifact_id='11', parts=[Part(text='text')]),
         ),
-        Message(**MESSAGE_PAYLOAD),
+        create_sample_message(),
         TaskStatusUpdateEvent(
-            taskId='task_123',
-            contextId='session-xyz',
-            status=TaskStatus(state=TaskState.working),
-            final=True,
+            task_id='task_123',
+            context_id='session-xyz',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
         ),
     ]
     cursor = 0
@@ -181,6 +130,8 @@ async def mock_dequeue() -> Any:
             event = events[cursor]
             cursor += 1
             return event
+        mock_event_queue.is_closed.return_value = True
+        raise asyncio.QueueEmpty()
 
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
@@ -199,8 +150,10 @@ async def test_consume_message_events(
     mock_event_queue: MagicMock,
 ):
     events = [
-        Message(**MESSAGE_PAYLOAD),
-        Message(**MESSAGE_PAYLOAD, final=True),
+        create_sample_message(),
+        create_sample_message(
+            message_id='222'
+        ),  # Another message (final doesn't exist in proto)
     ]
     cursor = 0
 
@@ -210,6 +163,8 @@ async def mock_dequeue() -> Any:
             event = events[cursor]
             cursor += 1
             return event
+        mock_event_queue.is_closed.return_value = True
+        raise asyncio.QueueEmpty()
 
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
@@ -219,3 +174,322 @@ async def mock_dequeue() -> Any:
     assert len(consumed_events) == 1
     assert consumed_events[0] == events[0]
     assert mock_event_queue.task_done.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_consume_all_raises_stored_exception(
+    event_consumer: EventConsumer,
+):
+    """Test that consume_all raises an exception if _exception is set."""
+    sample_exception = RuntimeError('Simulated agent error')
+    event_consumer._exception = sample_exception
+
+    with pytest.raises(RuntimeError, match='Simulated agent error'):
+        async for _ in event_consumer.consume_all():
+            pass  # Should not reach here
+
+
+@pytest.mark.asyncio
+async def test_consume_all_stops_on_queue_closed_and_confirmed_closed(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock
+):
+    """Test consume_all stops if QueueShutDown is raised and queue.is_closed() is True."""
+    # Simulate the queue raising QueueShutDown (which is asyncio.QueueEmpty or QueueShutdown)
+    mock_event_queue.dequeue_event.side_effect = QueueShutDown(
+        'Queue is empty/closed'
+    )
+    # Simulate the queue confirming it's closed
+    mock_event_queue.is_closed.return_value = True
+
+    consumed_events = []
+    async for event in event_consumer.consume_all():
+        consumed_events.append(event)  # Should not happen
+
+    assert (
+        len(consumed_events) == 0
+    )  # No events should be consumed as it breaks on QueueShutDown
+    mock_event_queue.dequeue_event.assert_called_once()  # Should attempt to dequeue once
+    mock_event_queue.is_closed.assert_called_once()  # Should check if closed
+
+
+@pytest.mark.asyncio
+async def test_consume_all_continues_on_queue_empty_if_not_really_closed(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock
+):
+    """Test that QueueShutDown with is_closed=False allows loop to continue via timeout."""
+    final_event = create_sample_message(message_id='final_event_id')
+
+    # Setup dequeue_event behavior:
+    # 1. Raise QueueShutDown (e.g., asyncio.QueueEmpty)
+    # 2. Return the final_event
+    # 3. Raise QueueShutDown again (to terminate after final_event)
+    dequeue_effects = [
+        QueueShutDown('Simulated temporary empty'),
+        final_event,
+        QueueShutDown('Queue closed after final event'),
+    ]
+    mock_event_queue.dequeue_event.side_effect = dequeue_effects
+
+    # Setup is_closed behavior:
+    # 1. False when QueueShutDown is first raised (so loop doesn't break)
+    # 2. True after final_event is processed and QueueShutDown is raised again
+    is_closed_effects = [False, True]
+    mock_event_queue.is_closed.side_effect = is_closed_effects
+
+    # Patch asyncio.wait_for used inside consume_all
+    # The goal is that the first QueueShutDown leads to a TimeoutError inside consume_all,
+    # the loop continues, and then the final_event is fetched.
+
+    # To reliably test the timeout behavior within consume_all, we adjust the consumer's
+    # internal timeout to be very short for the test.
+    event_consumer._timeout = 0.001
+
+    consumed_events = []
+    async for event in event_consumer.consume_all():
+        consumed_events.append(event)
+
+    assert len(consumed_events) == 1
+    assert consumed_events[0] == final_event
+
+    # Dequeue attempts:
+    # 1. Raises QueueShutDown (is_closed=False, leads to TimeoutError, loop continues)
+    # 2. Returns final_event (which is a Message, causing consume_all to break)
+    assert (
+        mock_event_queue.dequeue_event.call_count == 2
+    )  # Only two calls needed
+
+    # is_closed calls:
+    # 1. After first QueueShutDown (returns False)
+    # The second QueueShutDown is not reached because Message breaks the loop.
+    assert mock_event_queue.is_closed.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_consume_all_handles_queue_empty_when_closed_python_version_agnostic(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock, monkeypatch
+):
+    """Ensure consume_all stops with no events when queue is closed and dequeue_event raises asyncio.QueueEmpty (Python version-agnostic)."""
+    # Make QueueShutDown a distinct exception (not QueueEmpty) to emulate py3.13 semantics
+    from a2a.server.events import event_consumer as ec
+
+    class QueueShutDown(Exception):
+        pass
+
+    monkeypatch.setattr(ec, 'QueueShutDown', QueueShutDown, raising=True)
+
+    # Simulate queue reporting closed while dequeue raises QueueEmpty
+    mock_event_queue.dequeue_event.side_effect = asyncio.QueueEmpty(
+        'closed/empty'
+    )
+    mock_event_queue.is_closed.return_value = True
+
+    consumed_events = []
+    async for event in event_consumer.consume_all():
+        consumed_events.append(event)
+
+    assert consumed_events == []
+    mock_event_queue.dequeue_event.assert_called_once()
+    mock_event_queue.is_closed.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_consume_all_continues_on_queue_empty_when_not_closed(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock, monkeypatch
+):
+    """Ensure consume_all continues after asyncio.QueueEmpty when queue is open, yielding the next (final) event."""
+    # First dequeue raises QueueEmpty (transient empty), then a final Message arrives
+    final = create_sample_message(message_id='final')
+    mock_event_queue.dequeue_event.side_effect = [
+        asyncio.QueueEmpty('temporarily empty'),
+        final,
+    ]
+    mock_event_queue.is_closed.return_value = False
+
+    # Make the polling responsive in tests
+    event_consumer._timeout = 0.001
+
+    consumed = []
+    async for ev in event_consumer.consume_all():
+        consumed.append(ev)
+
+    assert consumed == [final]
+    assert mock_event_queue.dequeue_event.call_count == 2
+    mock_event_queue.is_closed.assert_called_once()
+
+
+def test_agent_task_callback_sets_exception(event_consumer: EventConsumer):
+    """Test that agent_task_callback sets _exception if the task had one."""
+    mock_task = MagicMock(spec=asyncio.Task)
+    mock_task.cancelled.return_value = False
+    mock_task.done.return_value = True
+    sample_exception = ValueError('Task failed')
+    mock_task.exception.return_value = sample_exception
+
+    event_consumer.agent_task_callback(mock_task)
+
+    assert event_consumer._exception == sample_exception
+    mock_task.exception.assert_called_once()
+
+
+def test_agent_task_callback_no_exception(event_consumer: EventConsumer):
+    """Test that agent_task_callback does nothing if the task has no exception."""
+    mock_task = MagicMock(spec=asyncio.Task)
+    mock_task.cancelled.return_value = False
+    mock_task.done.return_value = True
+    mock_task.exception.return_value = None  # No exception
+
+    event_consumer.agent_task_callback(mock_task)
+
+    assert event_consumer._exception is None  # Should remain None
+    mock_task.exception.assert_called_once()
+
+
+def test_agent_task_callback_cancelled_task(event_consumer: EventConsumer):
+    """Test that agent_task_callback does nothing if the task has no exception."""
+    mock_task = MagicMock(spec=asyncio.Task)
+    mock_task.cancelled.return_value = True
+    mock_task.done.return_value = True
+    sample_exception = ValueError('Task still running')
+    mock_task.exception.return_value = sample_exception
+
+    event_consumer.agent_task_callback(mock_task)
+
+    assert event_consumer._exception is None  # Should remain None
+    mock_task.exception.assert_not_called()
+
+
+def test_agent_task_callback_not_done_task(event_consumer: EventConsumer):
+    """Test that agent_task_callback does nothing if the task has no exception."""
+    mock_task = MagicMock(spec=asyncio.Task)
+    mock_task.cancelled.return_value = False
+    mock_task.done.return_value = False
+    sample_exception = ValueError('Task is cancelled')
+    mock_task.exception.return_value = sample_exception
+
+    event_consumer.agent_task_callback(mock_task)
+
+    assert event_consumer._exception is None  # Should remain None
+    mock_task.exception.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_consume_all_handles_validation_error(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock
+):
+    """Test that consume_all gracefully handles a pydantic.ValidationError."""
+    # Simulate dequeue_event raising a ValidationError
+    mock_event_queue.dequeue_event.side_effect = [
+        ValidationError.from_exception_data(title='Test Error', line_errors=[]),
+        asyncio.CancelledError,  # To stop the loop for the test
+    ]
+
+    with patch(
+        'a2a.server.events.event_consumer.logger.error'
+    ) as logger_error_mock:
+        with pytest.raises(asyncio.CancelledError):
+            async for _ in event_consumer.consume_all():
+                pass
+
+        # Check that the specific error was logged and the consumer continued
+        logger_error_mock.assert_called_once()
+        assert (
+            'Invalid event format received' in logger_error_mock.call_args[0][0]
+        )
+
+
+@pytest.mark.xfail(reason='https://github.com/a2aproject/a2a-python/issues/869')
+@pytest.mark.asyncio
+async def test_graceful_close_allows_tapped_queues_to_drain() -> None:
+    parent_queue = EventQueueLegacy(max_queue_size=10)
+    child_queue = await parent_queue.tap()
+
+    fast_consumer_done = asyncio.Event()
+
+    # Producer
+    async def produce() -> None:
+        await parent_queue.enqueue_event(
+            TaskStatusUpdateEvent(
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING)
+            )
+        )
+        await parent_queue.enqueue_event(
+            TaskStatusUpdateEvent(
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING)
+            )
+        )
+        await parent_queue.enqueue_event(Message(message_id='final'))
+
+    # Fast consumer on parent queue
+    async def fast_consume() -> list:
+        consumer = EventConsumer(parent_queue)
+        events = [event async for event in consumer.consume_all()]
+        fast_consumer_done.set()
+        return events
+
+    # Slow consumer on child queue
+    async def slow_consume() -> list:
+        consumer = EventConsumer(child_queue)
+        events = []
+        async for event in consumer.consume_all():
+            events.append(event)
+            # Wait for fast_consume to complete (and trigger close) before
+            # consuming further events to ensure they aren't prematurely dropped.
+            await fast_consumer_done.wait()
+        return events
+
+    # Run producer and consumers
+    producer_task = asyncio.create_task(produce())
+
+    fast_task = asyncio.create_task(fast_consume())
+    slow_task = asyncio.create_task(slow_consume())
+
+    await producer_task
+    fast_events = await fast_task
+    slow_events = await slow_task
+
+    assert len(fast_events) == 3
+    assert len(slow_events) == 3
+
+
+@pytest.mark.xfail(
+    reason='https://github.com/a2aproject/a2a-python/issues/869',
+    raises=asyncio.TimeoutError,
+)
+@pytest.mark.asyncio
+async def test_background_close_deadlocks_on_trailing_events() -> None:
+    queue = EventQueueLegacy()
+
+    # Producer enqueues a final event, but then enqueues another event
+    # (e.g., simulating a delayed log message, race condition, or multiple messages).
+    await queue.enqueue_event(Message(message_id='final'))
+    await queue.enqueue_event(Message(message_id='trailing_log'))
+
+    # Consumer dequeues 'final' but stops there (e.g. because it is a final event).
+    event = await queue.dequeue_event()
+    assert isinstance(event, Message) and event.message_id == 'final'
+    queue.task_done()
+
+    # Now attempt a graceful close. This demonstrates the deadlock that
+    # the previous implementation (with background task and clear_parent_events)
+    # was trying to solve.
+    await asyncio.wait_for(queue.close(immediate=False), timeout=0.1)
+
+
+@pytest.mark.asyncio
+async def test_consume_all_handles_actual_queue_shutdown(
+    event_consumer: EventConsumer, mock_event_queue: AsyncMock
+):
+    """Ensure consume_all stops when queue is closed and dequeue_event raises the actual QueueShutDown from event_queue."""
+    from a2a.server.events.event_queue import QueueShutDown
+
+    mock_event_queue.dequeue_event.side_effect = QueueShutDown(
+        'Queue is closed'
+    )
+    mock_event_queue.is_closed.return_value = True
+
+    consumed_events = []
+    # This should exit cleanly because consume_all correctly catches the QueueShutDown exception.
+    async for event in event_consumer.consume_all():
+        consumed_events.append(event)
+
+    assert len(consumed_events) == 0
diff --git a/tests/server/events/test_event_queue.py b/tests/server/events/test_event_queue.py
index 5b440fa1a..b45d99003 100644
--- a/tests/server/events/test_event_queue.py
+++ b/tests/server/events/test_event_queue.py
@@ -1,104 +1,532 @@
 import asyncio
+
+from typing import Any
+
 import pytest
-from a2a.server.events.event_queue import EventQueue
+
+from a2a.server.events.event_queue import (
+    DEFAULT_MAX_QUEUE_SIZE,
+    EventQueueLegacy,
+    QueueShutDown,
+)
+from a2a.server.jsonrpc_models import JSONRPCError
 from a2a.types import (
-    A2AError,
-    JSONRPCError,
+    TaskNotFoundError,
+)
+from a2a.types.a2a_pb2 import (
+    Artifact,
     Message,
+    Part,
+    Role,
     Task,
     TaskArtifactUpdateEvent,
-    TaskStatusUpdateEvent,
-    TaskStatus,
     TaskState,
-    Artifact,
-    Part,
-    TextPart,
-    TaskNotFoundError,
+    TaskStatus,
+    TaskStatusUpdateEvent,
 )
-from typing import Any
 
-MINIMAL_TASK: dict[str, Any] = {
-    'id': '123',
-    'contextId': 'session-xyz',
-    'status': {'state': 'submitted'},
-    'type': 'task',
-}
-MESSAGE_PAYLOAD: dict[str, Any] = {
-    'role': 'agent',
-    'parts': [{'text': 'test message'}],
-    'messageId': '111',
-}
+
+def create_sample_message(message_id: str = '111') -> Message:
+    """Create a sample Message proto object."""
+    return Message(
+        message_id=message_id,
+        role=Role.ROLE_AGENT,
+        parts=[Part(text='test message')],
+    )
+
+
+def create_sample_task(
+    task_id: str = '123', context_id: str = 'session-xyz'
+) -> Task:
+    """Create a sample Task proto object."""
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+
+class QueueJoinWrapper:
+    """A wrapper to intercept and signal when `queue.join()` is called."""
+
+    def __init__(self, original: Any, join_reached: asyncio.Event) -> None:
+        self.original = original
+        self.join_reached = join_reached
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.original, name)
+
+    async def join(self) -> None:
+        self.join_reached.set()
+        await self.original.join()
 
 
 @pytest.fixture
-def event_queue() -> EventQueue:
-    return EventQueue()
+def event_queue() -> EventQueueLegacy:
+    return EventQueueLegacy()
 
 
-@pytest.mark.asyncio
-async def test_enqueue_and_dequeue_event(event_queue: EventQueue) -> None:
-    """Test that an event can be enqueued and dequeued."""
-    event = Message(**MESSAGE_PAYLOAD)
-    event_queue.enqueue_event(event)
-    dequeued_event = await event_queue.dequeue_event()
-    assert dequeued_event == event
+def test_constructor_default_max_queue_size() -> None:
+    """Test that the queue is created with the default max size."""
+    eq = EventQueueLegacy()
+    assert eq.queue.maxsize == DEFAULT_MAX_QUEUE_SIZE
+
+
+def test_constructor_max_queue_size() -> None:
+    """Test that the asyncio.Queue is created with the specified max_queue_size."""
+    custom_size = 123
+    eq = EventQueueLegacy(max_queue_size=custom_size)
+    assert eq.queue.maxsize == custom_size
+
+
+def test_constructor_invalid_max_queue_size() -> None:
+    """Test that a ValueError is raised for non-positive max_queue_size."""
+    with pytest.raises(
+        ValueError, match='max_queue_size must be greater than 0'
+    ):
+        EventQueueLegacy(max_queue_size=0)
+    with pytest.raises(
+        ValueError, match='max_queue_size must be greater than 0'
+    ):
+        EventQueueLegacy(max_queue_size=-10)
 
 
 @pytest.mark.asyncio
-async def test_dequeue_event_no_wait(event_queue: EventQueue) -> None:
-    """Test dequeue_event with no_wait=True."""
-    event = Task(**MINIMAL_TASK)
-    event_queue.enqueue_event(event)
-    dequeued_event = await event_queue.dequeue_event(no_wait=True)
-    assert dequeued_event == event
+async def test_event_queue_async_context_manager(
+    event_queue: EventQueueLegacy,
+) -> None:
+    """Test that EventQueueLegacy can be used as an async context manager."""
+    async with event_queue as q:
+        assert q is event_queue
+        assert event_queue.is_closed() is False
+    assert event_queue.is_closed() is True
 
 
 @pytest.mark.asyncio
-async def test_dequeue_event_empty_queue_no_wait(
-    event_queue: EventQueue,
+async def test_event_queue_async_context_manager_on_exception(
+    event_queue: EventQueueLegacy,
 ) -> None:
-    """Test dequeue_event with no_wait=True when the queue is empty."""
-    with pytest.raises(asyncio.QueueEmpty):
-        await event_queue.dequeue_event(no_wait=True)
+    """Test that close() is called even when an exception occurs inside the context."""
+    with pytest.raises(RuntimeError, match='boom'):
+        async with event_queue:
+            raise RuntimeError('boom')
+    assert event_queue.is_closed() is True
+
+
+@pytest.mark.asyncio
+async def test_enqueue_and_dequeue_event(event_queue: EventQueueLegacy) -> None:
+    """Test that an event can be enqueued and dequeued."""
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+    dequeued_event = await event_queue.dequeue_event()
+    assert dequeued_event == event
 
 
 @pytest.mark.asyncio
-async def test_dequeue_event_wait(event_queue: EventQueue) -> None:
+async def test_dequeue_event_wait(event_queue: EventQueueLegacy) -> None:
     """Test dequeue_event with the default wait behavior."""
     event = TaskStatusUpdateEvent(
-        taskId='task_123',
-        contextId='session-xyz',
-        status=TaskStatus(state=TaskState.working),
-        final=True,
+        task_id='task_123',
+        context_id='session-xyz',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
     )
-    event_queue.enqueue_event(event)
+    await event_queue.enqueue_event(event)
     dequeued_event = await event_queue.dequeue_event()
     assert dequeued_event == event
 
 
 @pytest.mark.asyncio
-async def test_task_done(event_queue: EventQueue) -> None:
+async def test_task_done(event_queue: EventQueueLegacy) -> None:
     """Test the task_done method."""
     event = TaskArtifactUpdateEvent(
-        taskId='task_123',
-        contextId='session-xyz',
-        artifact=Artifact(artifactId='11', parts=[Part(TextPart(text='text'))]),
+        task_id='task_123',
+        context_id='session-xyz',
+        artifact=Artifact(artifact_id='11', parts=[Part(text='text')]),
     )
-    event_queue.enqueue_event(event)
+    await event_queue.enqueue_event(event)
     _ = await event_queue.dequeue_event()
     event_queue.task_done()
 
 
 @pytest.mark.asyncio
 async def test_enqueue_different_event_types(
-    event_queue: EventQueue,
+    event_queue: EventQueueLegacy,
 ) -> None:
     """Test enqueuing different types of events."""
     events: list[Any] = [
-        A2AError(TaskNotFoundError()),
+        TaskNotFoundError(),
         JSONRPCError(code=111, message='rpc error'),
     ]
     for event in events:
-        event_queue.enqueue_event(event)
+        await event_queue.enqueue_event(event)
         dequeued_event = await event_queue.dequeue_event()
         assert dequeued_event == event
+
+
+@pytest.mark.asyncio
+async def test_enqueue_event_propagates_to_children(
+    event_queue: EventQueueLegacy,
+) -> None:
+    """Test that events are enqueued to tapped child queues."""
+    child_queue1 = await event_queue.tap()
+    child_queue2 = await event_queue.tap()
+
+    event1 = create_sample_message()
+    event2 = create_sample_task()
+
+    await event_queue.enqueue_event(event1)
+    await event_queue.enqueue_event(event2)
+
+    # Check parent queue
+    assert await event_queue.dequeue_event() == event1
+    assert await event_queue.dequeue_event() == event2
+
+    # Check child queue 1
+    assert await child_queue1.dequeue_event() == event1
+    assert await child_queue1.dequeue_event() == event2
+
+    # Check child queue 2
+    assert await child_queue2.dequeue_event() == event1
+    assert await child_queue2.dequeue_event() == event2
+
+
+@pytest.mark.asyncio
+async def test_enqueue_event_when_closed(
+    event_queue: EventQueueLegacy,
+    expected_queue_closed_exception: type[Exception],
+) -> None:
+    """Test that no event is enqueued if the parent queue is closed."""
+    await event_queue.close()  # Close the queue first
+
+    event = create_sample_message()
+    # Attempt to enqueue, should do nothing or log a warning as per implementation
+    await event_queue.enqueue_event(event)
+
+    # Verify the queue is still empty
+    with pytest.raises(expected_queue_closed_exception):
+        await event_queue.dequeue_event()
+
+    # Also verify child queues are not affected directly by parent's enqueue attempt when closed
+    # (though they would be closed too by propagation)
+    child_queue = (
+        await event_queue.tap()
+    )  # Tap after close might be weird, but let's see
+    # The current implementation would add it to _children
+    # and then child.close() would be called.
+    # A more robust test for child propagation is in test_close_propagates
+    await (
+        child_queue.close()
+    )  # ensure child is also seen as closed for this test's purpose
+    with pytest.raises(expected_queue_closed_exception):
+        await child_queue.dequeue_event()
+
+
+@pytest.fixture
+def expected_queue_closed_exception() -> type[Exception]:
+    return QueueShutDown
+
+
+@pytest.mark.asyncio
+async def test_dequeue_event_closed_and_empty_waits_then_raises(
+    event_queue: EventQueueLegacy,
+    expected_queue_closed_exception: type[Exception],
+) -> None:
+    """Test dequeue_event raises QueueEmpty eventually when closed, empty, and no_wait=False."""
+    await event_queue.close()
+    assert event_queue.is_closed()
+    with pytest.raises(expected_queue_closed_exception):
+        event_queue.queue.get_nowait()  # verify internal queue is empty
+
+    # This test is tricky because await event_queue.dequeue_event() would hang if not for the close check.
+    # The current implementation's dequeue_event checks `is_closed` first.
+    # If closed and empty, it raises QueueEmpty immediately (on Python <= 3.12).
+    # On Python 3.13+, this check is skipped and asyncio.Queue.get() raises QueueShutDown instead.
+    # The "waits_then_raises" scenario described in the subtask implies the `get()` might wait.
+    # However, the current code:
+    # async with self._lock:
+    #     if self._is_closed and self.queue.empty():
+    # event = await self.queue.get() -> this line is not reached if closed and empty.
+
+    # So, for the current implementation, it will raise QueueEmpty immediately.
+    with pytest.raises(expected_queue_closed_exception):
+        await event_queue.dequeue_event()
+
+    # If the implementation were to change to allow `await self.queue.get()`
+    # to be called even when closed (to drain it), then a timeout test would be needed.
+    # For now, testing the current behavior.
+    # Example of a timeout test if it were to wait:
+    # with pytest.raises(asyncio.TimeoutError): # Or QueueEmpty if that's what join/shutdown causes get() to raise
+
+
+@pytest.mark.asyncio
+async def test_tap_creates_child_queue(event_queue: EventQueueLegacy) -> None:
+    """Test that tap creates a new EventQueueLegacy and adds it to children."""
+    initial_children_count = len(event_queue._children)
+
+    child_queue = await event_queue.tap()
+
+    assert isinstance(child_queue, EventQueueLegacy)
+    assert child_queue != event_queue  # Ensure it's a new instance
+    assert len(event_queue._children) == initial_children_count + 1
+    assert child_queue in event_queue._children
+
+    # Test that the new child queue has the default max size (or specific if tap could configure it)
+    assert child_queue.queue.maxsize == DEFAULT_MAX_QUEUE_SIZE
+
+
+@pytest.mark.asyncio
+async def test_close_idempotent(event_queue: EventQueueLegacy) -> None:
+    await event_queue.close()
+    assert event_queue.is_closed() is True
+    await event_queue.close()
+    assert event_queue.is_closed() is True
+
+
+@pytest.mark.asyncio
+async def test_is_closed_reflects_state(event_queue: EventQueueLegacy) -> None:
+    """Test that is_closed() returns the correct state before and after closing."""
+    assert event_queue.is_closed() is False  # Initially open
+
+    await event_queue.close()
+
+    assert event_queue.is_closed() is True  # Closed after calling close()
+
+
+@pytest.mark.asyncio
+async def test_close_with_immediate_true(event_queue: EventQueueLegacy) -> None:
+    """Test close with immediate=True clears events immediately."""
+    # Add some events to the queue
+    event1 = create_sample_message()
+    event2 = create_sample_task()
+    await event_queue.enqueue_event(event1)
+    await event_queue.enqueue_event(event2)
+
+    # Verify events are in queue
+    assert not event_queue.queue.empty()
+
+    # Close with immediate=True
+    await event_queue.close(immediate=True)
+
+    # Verify queue is closed and empty
+    assert event_queue.is_closed() is True
+    assert event_queue.queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_close_immediate_propagates_to_children(
+    event_queue: EventQueueLegacy,
+) -> None:
+    """Test that immediate parameter is propagated to child queues."""
+    child_queue = await event_queue.tap()
+
+    # Add events to both parent and child
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+
+    assert child_queue.is_closed() is False
+    assert child_queue.queue.empty() is False
+
+    # close event queue
+    await event_queue.close(immediate=True)
+
+    # Verify child queue was called and empty with immediate=True
+    assert child_queue.is_closed() is True
+    assert child_queue.queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_close_graceful_waits_for_join_and_children(
+    event_queue: EventQueueLegacy,
+) -> None:
+    child = await event_queue.tap()
+    await event_queue.enqueue_event(create_sample_message())
+
+    join_reached = asyncio.Event()
+    event_queue._queue = QueueJoinWrapper(event_queue.queue, join_reached)
+    child._queue = QueueJoinWrapper(child.queue, join_reached)
+
+    close_task = asyncio.create_task(event_queue.close(immediate=False))
+    await join_reached.wait()
+
+    assert event_queue.is_closed()
+    assert child.is_closed()
+    assert not close_task.done()
+
+    await event_queue.dequeue_event()
+    event_queue.task_done()
+
+    await child.dequeue_event()
+    child.task_done()
+
+    await asyncio.wait_for(close_task, timeout=1.0)
+
+
+@pytest.mark.asyncio
+async def test_close_propagates_to_children(
+    event_queue: EventQueueLegacy,
+) -> None:
+    child_queue1 = await event_queue.tap()
+    child_queue2 = await event_queue.tap()
+    await event_queue.close()
+    assert child_queue1.is_closed()
+    assert child_queue2.is_closed()
+
+
+@pytest.mark.xfail(reason='https://github.com/a2aproject/a2a-python/issues/869')
+@pytest.mark.asyncio
+async def test_enqueue_close_race_condition() -> None:
+    queue = EventQueueLegacy()
+    event = create_sample_message()
+
+    enqueue_task = asyncio.create_task(queue.enqueue_event(event))
+    close_task = asyncio.create_task(queue.close(immediate=False))
+
+    try:
+        results = await asyncio.wait_for(
+            asyncio.gather(enqueue_task, close_task, return_exceptions=True),
+            timeout=1.0,
+        )
+        for res in results:
+            if (
+                isinstance(res, Exception)
+                and type(res).__name__ != 'QueueShutDown'
+            ):
+                raise res
+    except asyncio.TimeoutError:
+        pytest.fail(
+            'Deadlock in close() because enqueue_event put an item during close but before join()'
+        )
+
+
+@pytest.mark.asyncio
+async def test_event_queue_dequeue_immediate_false(
+    event_queue: EventQueueLegacy,
+) -> None:
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    # Start close in background so it can wait for join()
+    close_task = asyncio.create_task(event_queue.close(immediate=False))
+
+    # The event is still in the queue, we can dequeue it
+    assert await event_queue.dequeue_event() == msg
+    event_queue.task_done()
+
+    await close_task
+
+    # Queue is now empty and closed
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_dequeue_immediate_true(
+    event_queue: EventQueueLegacy,
+) -> None:
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    await event_queue.close(immediate=True)
+    # The queue is immediately flushed, so dequeue should raise QueueShutDown
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_enqueue_when_closed(
+    event_queue: EventQueueLegacy,
+) -> None:
+    await event_queue.close(immediate=True)
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    # Enqueue should have returned without doing anything
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_shutdown_wakes_getter(
+    event_queue: EventQueueLegacy,
+) -> None:
+    original_queue = event_queue.queue
+    getter_reached_get = asyncio.Event()
+
+    class QueueWrapper:
+        def __getattr__(self, name):
+            return getattr(original_queue, name)
+
+        async def get(self):
+            getter_reached_get.set()
+            return await original_queue.get()
+
+    # Replace the underlying queue with a wrapper to intercept `get`
+    event_queue._queue = QueueWrapper()
+
+    async def getter():
+        with pytest.raises(QueueShutDown):
+            await event_queue.dequeue_event()
+
+    task = asyncio.create_task(getter())
+    await getter_reached_get.wait()
+
+    # At this point, getter is guaranteed to be awaiting the original_queue.get()
+    await event_queue.close(immediate=True)
+    await asyncio.wait_for(task, timeout=1.0)
+
+
+@pytest.mark.parametrize(
+    'immediate, expected_events, close_blocks',
+    [
+        (False, (1, 1), True),
+        (True, (0, 0), False),
+    ],
+)
+@pytest.mark.asyncio
+async def test_event_queue_close_behaviors(
+    event_queue: EventQueueLegacy,
+    immediate: bool,
+    expected_events: tuple[int, int],
+    close_blocks: bool,
+) -> None:
+    expected_parent_events, expected_child_events = expected_events
+    child_queue = await event_queue.tap()
+
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+
+    # We need deterministic event waiting to prevent sleep()
+    join_reached = asyncio.Event()
+
+    # Apply wrappers so we know exactly when join() starts
+    event_queue._queue = QueueJoinWrapper(event_queue.queue, join_reached)
+    child_queue._queue = QueueJoinWrapper(child_queue.queue, join_reached)
+
+    close_task = asyncio.create_task(event_queue.close(immediate=immediate))
+
+    if close_blocks:
+        await join_reached.wait()
+        assert not close_task.done(), (
+            'close() should block waiting for queue to be drained'
+        )
+    else:
+        # We await it with a tiny timeout to ensure the task had time to run,
+        # but because immediate=True, it runs without blocking at all.
+        await asyncio.wait_for(close_task, timeout=0.1)
+        assert close_task.done(), 'close() should not block'
+
+    # Verify parent queue state
+    if expected_parent_events == 0:
+        with pytest.raises(QueueShutDown):
+            await event_queue.dequeue_event()
+    else:
+        assert await event_queue.dequeue_event() == msg
+        event_queue.task_done()
+
+    # Verify child queue state
+    if expected_child_events == 0:
+        with pytest.raises(QueueShutDown):
+            await child_queue.dequeue_event()
+    else:
+        assert await child_queue.dequeue_event() == msg
+        child_queue.task_done()
+
+    # Ensure close_task finishes cleanly
+    await asyncio.wait_for(close_task, timeout=1.0)
diff --git a/tests/server/events/test_event_queue_v2.py b/tests/server/events/test_event_queue_v2.py
new file mode 100644
index 000000000..35b3a68d9
--- /dev/null
+++ b/tests/server/events/test_event_queue_v2.py
@@ -0,0 +1,1012 @@
+import asyncio
+import logging
+
+from typing import Any
+from unittest import mock
+
+import pytest
+import pytest_asyncio
+
+from a2a.server.events.event_queue import (
+    DEFAULT_MAX_QUEUE_SIZE,
+    Event,
+    EventQueue,
+    QueueShutDown,
+)
+from a2a.server.events.event_queue_v2 import (
+    EventQueueSink,
+    EventQueueSource,
+)
+from a2a.server.jsonrpc_models import JSONRPCError
+from a2a.types import (
+    TaskNotFoundError,
+)
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    Message,
+    Part,
+    Role,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+
+def create_sample_message(message_id: str = '111') -> Message:
+    """Create a sample Message proto object."""
+    return Message(
+        message_id=message_id,
+        role=Role.ROLE_AGENT,
+        parts=[Part(text='test message')],
+    )
+
+
+def create_sample_task(
+    task_id: str = '123', context_id: str = 'session-xyz'
+) -> Task:
+    """Create a sample Task proto object."""
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+
+class QueueJoinWrapper:
+    """A wrapper to intercept and signal when `queue.join()` is called."""
+
+    def __init__(self, original: Any, join_reached: asyncio.Event) -> None:
+        self.original = original
+        self.join_reached = join_reached
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.original, name)
+
+    async def join(self) -> None:
+        self.join_reached.set()
+        await self.original.join()
+
+
+@pytest_asyncio.fixture
+async def event_queue() -> EventQueueSource:
+    return EventQueueSource()
+
+
+@pytest.mark.asyncio
+async def test_constructor_default_max_queue_size() -> None:
+    """Test that the queue is created with the default max size."""
+    eq = EventQueueSource()
+    assert eq.queue.maxsize == DEFAULT_MAX_QUEUE_SIZE
+
+
+@pytest.mark.asyncio
+async def test_constructor_max_queue_size() -> None:
+    """Test that the asyncio.Queue is created with the specified max_queue_size."""
+    custom_size = 123
+    eq = EventQueueSource(max_queue_size=custom_size)
+    assert eq.queue.maxsize == custom_size
+
+
+@pytest.mark.asyncio
+async def test_constructor_invalid_max_queue_size() -> None:
+    """Test that a ValueError is raised for non-positive max_queue_size."""
+    with pytest.raises(
+        ValueError, match='max_queue_size must be greater than 0'
+    ):
+        EventQueueSource(max_queue_size=0)
+    with pytest.raises(
+        ValueError, match='max_queue_size must be greater than 0'
+    ):
+        EventQueueSource(max_queue_size=-10)
+
+
+@pytest.mark.asyncio
+async def test_event_queue_async_context_manager(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that EventQueue can be used as an async context manager."""
+    async with event_queue as q:
+        assert q is event_queue
+        assert event_queue.is_closed() is False
+    assert event_queue.is_closed() is True
+
+
+@pytest.mark.asyncio
+async def test_event_queue_async_context_manager_on_exception(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that close() is called even when an exception occurs inside the context."""
+    with pytest.raises(RuntimeError, match='boom'):
+        async with event_queue:
+            raise RuntimeError('boom')
+    assert event_queue.is_closed() is True
+
+
+@pytest.mark.asyncio
+async def test_enqueue_and_dequeue_event(event_queue: EventQueueSource) -> None:
+    """Test that an event can be enqueued and dequeued."""
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+    dequeued_event = await event_queue.dequeue_event()
+    assert dequeued_event == event
+
+
+@pytest.mark.asyncio
+async def test_dequeue_event_wait(event_queue: EventQueueSource) -> None:
+    """Test dequeue_event with the default wait behavior."""
+    event = TaskStatusUpdateEvent(
+        task_id='task_123',
+        context_id='session-xyz',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+    )
+    await event_queue.enqueue_event(event)
+    dequeued_event = await event_queue.dequeue_event()
+    assert dequeued_event == event
+
+
+@pytest.mark.asyncio
+async def test_task_done(event_queue: EventQueueSource) -> None:
+    """Test the task_done method."""
+    event = TaskArtifactUpdateEvent(
+        task_id='task_123',
+        context_id='session-xyz',
+        artifact=Artifact(artifact_id='11', parts=[Part(text='text')]),
+    )
+    await event_queue.enqueue_event(event)
+    _ = await event_queue.dequeue_event()
+    event_queue.task_done()
+
+
+@pytest.mark.asyncio
+async def test_enqueue_different_event_types(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test enqueuing different types of events."""
+    events: list[Any] = [
+        TaskNotFoundError(),
+        JSONRPCError(code=111, message='rpc error'),
+    ]
+    for event in events:
+        await event_queue.enqueue_event(event)
+        dequeued_event = await event_queue.dequeue_event()
+        assert dequeued_event == event
+
+
+@pytest.mark.asyncio
+async def test_enqueue_event_propagates_to_children(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that events are enqueued to tapped child queues."""
+    child_queue1 = await event_queue.tap()
+    child_queue2 = await event_queue.tap()
+
+    event1 = create_sample_message()
+    event2 = create_sample_task()
+
+    await event_queue.enqueue_event(event1)
+    await event_queue.enqueue_event(event2)
+
+    # Check parent queue
+    assert await event_queue.dequeue_event() == event1
+    assert await event_queue.dequeue_event() == event2
+
+    # Check child queue 1
+    assert await child_queue1.dequeue_event() == event1
+    assert await child_queue1.dequeue_event() == event2
+
+    # Check child queue 2
+    assert await child_queue2.dequeue_event() == event1
+    assert await child_queue2.dequeue_event() == event2
+
+
+@pytest.mark.asyncio
+async def test_enqueue_event_when_closed(
+    event_queue: EventQueueSource,
+    expected_queue_closed_exception: type[Exception],
+) -> None:
+    """Test that no event is enqueued if the parent queue is closed."""
+    await event_queue.close()  # Close the queue first
+
+    event = create_sample_message()
+    # Attempt to enqueue, should do nothing or log a warning as per implementation
+    await event_queue.enqueue_event(event)
+
+    # Verify the queue is still empty
+    with pytest.raises(expected_queue_closed_exception):
+        await event_queue.dequeue_event()
+
+    # Also verify child queues are not affected directly by parent's enqueue attempt when closed
+    # (though they would be closed too by propagation)
+    with pytest.raises(expected_queue_closed_exception):
+        await event_queue.tap()
+
+
+@pytest.fixture
+def expected_queue_closed_exception() -> type[Exception]:
+    return QueueShutDown
+
+
+@pytest.mark.asyncio
+async def test_dequeue_event_closed_and_empty(
+    event_queue: EventQueueSource,
+    expected_queue_closed_exception: type[Exception],
+) -> None:
+    """Test dequeue_event raises QueueShutDown when closed and empty."""
+    await event_queue.close()
+    assert event_queue.is_closed()
+    # Ensure queue is actually empty (e.g. by trying a non-blocking get on internal queue)
+    with pytest.raises(expected_queue_closed_exception):
+        event_queue.queue.get_nowait()
+
+    with pytest.raises(expected_queue_closed_exception):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_tap_creates_child_queue(event_queue: EventQueueSource) -> None:
+    """Test that tap creates a new EventQueue and adds it to children."""
+    initial_children_count = len(event_queue._sinks)
+
+    child_queue = await event_queue.tap()
+
+    assert isinstance(child_queue, EventQueue)
+    assert child_queue != event_queue  # Ensure it's a new instance
+    assert len(event_queue._sinks) == initial_children_count + 1
+    assert child_queue in event_queue._sinks
+
+    # Test that the new child queue has the default max size (or specific if tap could configure it)
+    assert child_queue.queue.maxsize == DEFAULT_MAX_QUEUE_SIZE
+
+
+@pytest.mark.asyncio
+async def test_close_idempotent(event_queue: EventQueueSource) -> None:
+    await event_queue.close()
+    assert event_queue.is_closed() is True
+    await event_queue.close()
+    assert event_queue.is_closed() is True
+
+
+@pytest.mark.asyncio
+async def test_sink_close_idempotent_does_not_record_exception() -> None:
+    span = mock.MagicMock()
+    tracer = mock.MagicMock()
+    tracer.start_as_current_span.return_value.__enter__.return_value = span
+    tracer.start_as_current_span.return_value.__exit__.return_value = False
+
+    with mock.patch('opentelemetry.trace.get_tracer', return_value=tracer):
+        event_queue = EventQueueSource(create_default_sink=False)
+        sink = await event_queue.tap()
+
+        await sink.close(immediate=True)
+        await sink.close(immediate=True)
+        await event_queue.close(immediate=True)
+
+    tracer.start_as_current_span.assert_called()
+    span.record_exception.assert_not_called()
+    for call in span.set_status.call_args_list:
+        assert 'description' not in call.kwargs
+
+
+@pytest.mark.asyncio
+async def test_is_closed_reflects_state(event_queue: EventQueueSource) -> None:
+    """Test that is_closed() returns the correct state before and after closing."""
+    assert event_queue.is_closed() is False  # Initially open
+
+    await event_queue.close()
+
+    assert event_queue.is_closed() is True  # Closed after calling close()
+
+
+@pytest.mark.asyncio
+async def test_close_with_immediate_true(event_queue: EventQueueSource) -> None:
+    """Test close with immediate=True clears events immediately."""
+    # Add some events to the queue
+    event1 = create_sample_message()
+    event2 = create_sample_task()
+    await event_queue.enqueue_event(event1)
+    await event_queue.enqueue_event(event2)
+    await event_queue.test_only_join_incoming_queue()
+
+    # Verify events are in queue
+    assert not event_queue.queue.empty()
+
+    # Close with immediate=True
+    await event_queue.close(immediate=True)
+
+    # Verify queue is closed and empty
+    assert event_queue.is_closed() is True
+    assert event_queue.queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_close_immediate_propagates_to_children(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that immediate parameter is propagated to child queues."""
+    child_queue = await event_queue.tap()
+
+    # Add events to both parent and child
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+    await event_queue.test_only_join_incoming_queue()
+
+    assert child_queue.is_closed() is False
+    assert child_queue.queue.empty() is False
+
+    # close event queue
+    await event_queue.close(immediate=True)
+
+    # Verify child queue was called and empty with immediate=True
+    assert child_queue.is_closed() is True
+    assert child_queue.queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_close_graceful_waits_for_join_and_children(
+    event_queue: EventQueueSource,
+) -> None:
+    child = await event_queue.tap()
+    await event_queue.enqueue_event(create_sample_message())
+
+    join_reached = asyncio.Event()
+    event_queue._default_sink._queue = QueueJoinWrapper(
+        event_queue.queue, join_reached
+    )  # type: ignore
+    child._queue = QueueJoinWrapper(child.queue, join_reached)  # type: ignore
+
+    close_task = asyncio.create_task(event_queue.close(immediate=False))
+    await join_reached.wait()
+
+    assert event_queue.is_closed()
+    assert child.is_closed()
+    assert not close_task.done()
+
+    await event_queue.dequeue_event()
+    event_queue.task_done()
+
+    await child.dequeue_event()
+    child.task_done()
+
+    await asyncio.wait_for(close_task, timeout=1.0)
+
+
+@pytest.mark.asyncio
+async def test_close_propagates_to_children(
+    event_queue: EventQueueSource,
+) -> None:
+    child_queue1 = await event_queue.tap()
+    child_queue2 = await event_queue.tap()
+    await event_queue.close()
+    assert child_queue1.is_closed()
+    assert child_queue2.is_closed()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_dequeue_immediate_false(
+    event_queue: EventQueueSource,
+) -> None:
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    await event_queue.test_only_join_incoming_queue()
+    # Start close in background so it can wait for join()
+    close_task = asyncio.create_task(event_queue.close(immediate=False))
+
+    # The event is still in the queue, we can dequeue it
+    assert await event_queue.dequeue_event() == msg
+    event_queue.task_done()
+
+    await close_task
+
+    # Queue is now empty and closed
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_dequeue_immediate_true(
+    event_queue: EventQueueSource,
+) -> None:
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    await event_queue.close(immediate=True)
+    # The queue is immediately flushed, so dequeue should raise QueueShutDown
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_enqueue_when_closed(
+    event_queue: EventQueueSource,
+) -> None:
+    await event_queue.close(immediate=True)
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+    # Enqueue should have returned without doing anything
+    with pytest.raises(QueueShutDown):
+        await event_queue.dequeue_event()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_shutdown_wakes_getter(
+    event_queue: EventQueueSource,
+) -> None:
+    original_queue = event_queue.queue
+    getter_reached_get = asyncio.Event()
+
+    class QueueWrapper:
+        def __getattr__(self, name):
+            return getattr(original_queue, name)
+
+        async def get(self):
+            getter_reached_get.set()
+            return await original_queue.get()
+
+    # Replace the underlying queue with a wrapper to intercept `get`
+    event_queue._default_sink._queue = QueueWrapper()  # type: ignore
+
+    async def getter():
+        with pytest.raises(QueueShutDown):
+            await event_queue.dequeue_event()
+
+    task = asyncio.create_task(getter())
+    await getter_reached_get.wait()
+
+    # At this point, getter is guaranteed to be awaiting the original_queue.get()
+    await event_queue.close(immediate=True)
+    await asyncio.wait_for(task, timeout=1.0)
+
+
+@pytest.mark.parametrize(
+    'immediate, expected_events, close_blocks',
+    [
+        (False, (1, 1), True),
+        (True, (0, 0), False),
+    ],
+)
+@pytest.mark.asyncio
+async def test_event_queue_close_behaviors(
+    event_queue: EventQueueSource,
+    immediate: bool,
+    expected_events: tuple[int, int],
+    close_blocks: bool,
+) -> None:
+    expected_parent_events, expected_child_events = expected_events
+    child_queue = await event_queue.tap()
+
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+
+    # We need deterministic event waiting to prevent sleep()
+    join_reached = asyncio.Event()
+
+    # Apply wrappers so we know exactly when join() starts
+    event_queue._default_sink._queue = QueueJoinWrapper(
+        event_queue.queue, join_reached
+    )  # type: ignore
+    child_queue._queue = QueueJoinWrapper(child_queue.queue, join_reached)  # type: ignore
+
+    close_task = asyncio.create_task(event_queue.close(immediate=immediate))
+
+    if close_blocks:
+        await join_reached.wait()
+        assert not close_task.done(), (
+            'close() should block waiting for queue to be drained'
+        )
+    else:
+        # We await it with a tiny timeout to ensure the task had time to run,
+        # but because immediate=True, it runs without blocking at all.
+        await asyncio.wait_for(close_task, timeout=0.1)
+        assert close_task.done(), 'close() should not block'
+
+    # Verify parent queue state
+    if expected_parent_events == 0:
+        with pytest.raises(QueueShutDown):
+            await event_queue.dequeue_event()
+    else:
+        assert await event_queue.dequeue_event() == msg
+        event_queue.task_done()
+
+    # Verify child queue state
+    if expected_child_events == 0:
+        with pytest.raises(QueueShutDown):
+            await child_queue.dequeue_event()
+    else:
+        assert await child_queue.dequeue_event() == msg
+        child_queue.task_done()
+
+    # Ensure close_task finishes cleanly
+    await asyncio.wait_for(close_task, timeout=1.0)
+
+
+@pytest.mark.asyncio
+async def test_sink_only_raises_on_enqueue() -> None:
+    """Test that enqueuing to a sink-only queue raises an error."""
+    parent = EventQueueSource()
+    sink_queue = EventQueueSink(parent=parent)
+    event = create_sample_message()
+    with pytest.raises(
+        RuntimeError, match='Cannot enqueue to a sink-only queue'
+    ):
+        await sink_queue.enqueue_event(event)
+
+
+@pytest.mark.asyncio
+async def test_tap_creates_sink_only_queue(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that tap() creates a child queue that is sink-only."""
+    child_queue = await event_queue.tap()
+    assert hasattr(child_queue, '_parent') and child_queue._parent is not None  # type: ignore
+
+    event = create_sample_message()
+    with pytest.raises(
+        RuntimeError, match='Cannot enqueue to a sink-only queue'
+    ):
+        await child_queue.enqueue_event(event)
+
+
+@pytest.mark.asyncio
+async def test_tap_attaches_to_top_parent(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that tap() on a child queue attaches the new queue to the top parent."""
+    # First level child
+    child1 = await event_queue.tap()
+
+    # Second level child (tapped from child1)
+    child2 = await child1.tap()
+
+    # The top parent should have both child1 and child2 in its children list
+    assert child1 in event_queue._sinks
+    assert child2 in event_queue._sinks
+
+    # child1 should not have any children, because tap() attaches to top parent
+    assert True  # Child does not have children anymore
+
+    # Ensure events still flow to all queues
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+
+
+@pytest.mark.asyncio
+async def test_concurrent_enqueue_order_preserved() -> None:
+    """
+    Verifies that concurrent enqueues to a parent queue are preserved in
+    the exact same order in all child queues due to root serialization.
+    """
+    parent = EventQueueSource()
+    child = await parent.tap()
+
+    events = [create_sample_message(message_id=str(i)) for i in range(100)]
+
+    # Enqueue all concurrently
+    await asyncio.gather(*(parent.enqueue_event(e) for e in events))
+
+    parent_events = []
+    while not parent.queue.empty():
+        parent_events.append(await parent.dequeue_event())
+        parent.task_done()
+
+    child_events = []
+    while not child.queue.empty():
+        child_events.append(await child.dequeue_event())
+        child.task_done()
+
+    assert parent_events == child_events, (
+        'Order mismatch! Locking failed to serialize enqueues.'
+    )
+
+
+@pytest.mark.asyncio
+async def test_dispatch_task_failed(event_queue: EventQueueSource) -> None:
+    event_queue._dispatcher_task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await event_queue._dispatcher_task
+
+    event = create_sample_message()
+    await event_queue.enqueue_event(event)
+
+    with pytest.raises(QueueShutDown):
+        await asyncio.wait_for(event_queue.dequeue_event(), timeout=0.1)
+
+    # Event was never dequeued, but close() should still work after dispatcher was force cancelled.
+    await asyncio.wait_for(event_queue.close(immediate=False), timeout=0.1)
+
+
+@pytest.mark.asyncio
+async def test_close_immediate_awaits_dispatcher_without_sinks() -> None:
+    """A subscriber-less source must not leave its dispatcher pending on close.
+
+    Regression: a source created with create_default_sink=False and no taps has
+    no sinks for close()'s gather to await. close(immediate=True) cancels the
+    dispatcher task, so with nothing else to await it used to return while the
+    cancelled dispatcher was still pending, producing "Task was destroyed but it
+    is pending!". close() must await its own cancelled dispatcher task.
+    """
+    source = EventQueueSource(create_default_sink=False)
+    assert not source._dispatcher_task.done()
+
+    await source.close(immediate=True)
+
+    assert source._dispatcher_task.done()
+
+
+@pytest.mark.asyncio
+async def test_close_does_not_propagate_dispatcher_crash() -> None:
+    """close() awaits its dispatcher without surfacing a non-cancel crash.
+
+    close() is teardown (reachable from __aexit__) and must not raise, and
+    _dispatch_loop already logs its own exceptions. If the dispatcher died with a
+    non-cancel error, awaiting it in close() must not re-raise that error.
+    """
+    source = EventQueueSource(create_default_sink=False)
+
+    # Retire the real dispatcher, then stand in a task that has already failed
+    # with a non-cancel error, simulating a _dispatch_loop crash.
+    real = source._dispatcher_task
+    real.cancel()
+    try:
+        await real
+    except asyncio.CancelledError:
+        pass
+
+    async def crashed() -> None:
+        raise RuntimeError('dispatcher boom')
+
+    source._dispatcher_task = asyncio.ensure_future(crashed())
+    await asyncio.sleep(0.01)  # let it fail so the exception is stored
+
+    # Must return cleanly, not re-raise the dispatcher's RuntimeError.
+    await source.close(immediate=True)
+    assert source._dispatcher_task.done()
+
+
+@pytest.mark.asyncio
+async def test_concurrent_close_immediate_false() -> None:
+    """Test that concurrent close(immediate=False) calls both wait for join() deterministically."""
+    queue = EventQueueSource()
+    sink = await queue.tap()
+
+    event_arrived = asyncio.Event()
+    original_put_internal = sink._put_internal  # type: ignore
+
+    async def mock_put_internal(msg: Any) -> None:
+        await original_put_internal(msg)
+        event_arrived.set()
+
+    sink._put_internal = mock_put_internal  # type: ignore
+
+    event = Message()
+    await queue.enqueue_event(event)
+
+    # Deterministically wait for the event to be processed and reach the sink
+    await asyncio.wait_for(event_arrived.wait(), timeout=1.0)
+
+    class CustomJoinWrapper:
+        def __init__(self, original: Any) -> None:
+            self.original = original
+            self.join_count = 0
+            self.join_started_1 = asyncio.Event()
+            self.join_started_2 = asyncio.Event()
+
+        def __getattr__(self, name: str) -> Any:
+            return getattr(self.original, name)
+
+        async def join(self) -> None:
+            self.join_count += 1
+            if self.join_count == 1:
+                self.join_started_1.set()
+            elif self.join_count == 2:
+                self.join_started_2.set()
+            await self.original.join()
+
+    wrapper = CustomJoinWrapper(sink._queue)  # type: ignore
+    sink._queue = wrapper  # type: ignore
+
+    close_task_1 = asyncio.create_task(sink.close(immediate=False))
+    # Wait deterministically until the first close call reaches await queue.join()
+    await asyncio.wait_for(wrapper.join_started_1.wait(), timeout=1.0)
+    assert not close_task_1.done()
+
+    close_task_2 = asyncio.create_task(sink.close(immediate=False))
+    # Wait deterministically until the second close call reaches await queue.join()
+    await asyncio.wait_for(wrapper.join_started_2.wait(), timeout=1.0)
+    assert not close_task_2.done()
+
+    # To clean up and allow the queue to finish joining
+    await sink.dequeue_event()
+    sink.task_done()
+
+    # Now both tasks should complete
+    await asyncio.wait_for(
+        asyncio.gather(close_task_1, close_task_2), timeout=1.0
+    )
+
+
+@pytest.mark.asyncio
+async def test_dispatch_loop_logs_exceptions(
+    event_queue: EventQueueSource, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Test that exceptions raised by sinks during dispatch are logged."""
+    caplog.set_level(logging.ERROR)
+    sink = await event_queue.tap()
+
+    async def mock_put_internal(event: Any) -> None:
+        raise RuntimeError('simulated error')
+
+    sink._put_internal = mock_put_internal  # type: ignore
+
+    msg = create_sample_message()
+    await event_queue.enqueue_event(msg)
+
+    # Wait for dispatch loop to process
+    await event_queue.test_only_join_incoming_queue()
+
+    assert any(
+        record.levelname == 'ERROR'
+        and 'Error dispatching event to sink' in record.message
+        for record in caplog.records
+    )
+
+
+@pytest.mark.asyncio
+async def test_join_incoming_queue_cancels_join_task(
+    event_queue: EventQueueSource,
+) -> None:
+    """Test that _join_incoming_queue cancels join_task on CancelledError."""
+    # Tap a sink and block its processing so dispatcher and join() hang
+    sink = await event_queue.tap()
+    block_event = asyncio.Event()
+
+    async def mock_put_internal(event: Any) -> None:
+        await block_event.wait()
+
+    sink._put_internal = mock_put_internal  # type: ignore
+
+    # Enqueue a message so join() blocks
+    await event_queue.enqueue_event(create_sample_message())
+
+    join_reached = asyncio.Event()
+    event_queue._incoming_queue = QueueJoinWrapper(  # type: ignore
+        event_queue._incoming_queue, join_reached
+    )
+
+    join_task = asyncio.create_task(event_queue._join_incoming_queue())
+
+    # Wait deterministically until the internal task calls join()
+    await join_reached.wait()
+
+    # Cancel the wrapper task
+    join_task.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await join_task
+
+    # Unblock the sink and clean up
+    block_event.set()
+    await event_queue.dequeue_event()
+    event_queue.task_done()
+
+
+@pytest.mark.asyncio
+async def test_event_queue_capacity_order_and_concurrency() -> None:
+    """Test that EventQueue preserves order and handles concurrency with limited capacity."""
+    queue = EventQueueSource(max_queue_size=5)
+
+    # Create 10 tapped queues
+    tapped_queues = [await queue.tap(max_queue_size=5) for _ in range(10)]
+    all_queues: list[EventQueue] = [queue] + tapped_queues  # type: ignore
+
+    async def producer() -> None:
+        for i in range(100):
+            await queue.enqueue_event(create_sample_message(message_id=str(i)))
+
+    async def consumer(q: EventQueue) -> None:
+        for expected_i in range(100):
+            event = await q.dequeue_event()
+            assert isinstance(event, Message)
+            assert event.message_id == str(expected_i)
+            q.task_done()
+
+    consumer_tasks = [asyncio.create_task(consumer(q)) for q in all_queues]
+    producer_task = asyncio.create_task(producer())
+
+    await asyncio.wait_for(
+        asyncio.gather(producer_task, *consumer_tasks), timeout=1.0
+    )
+
+    await queue.close(immediate=True)
+
+
+@pytest.mark.asyncio
+async def test_event_queue_blocking_behavior() -> None:
+    _PARENT_QUEUE_SIZE = 10
+    _TAPPED_QUEUE_SIZE = 15
+
+    queue = EventQueueSource(max_queue_size=_PARENT_QUEUE_SIZE)
+    # tapped_queue initially has no consumer, so it will block.
+    tapped_queue = await queue.tap(max_queue_size=_TAPPED_QUEUE_SIZE)
+
+    producer_task_done = asyncio.Event()
+    enqueued_count = 0
+
+    async def producer() -> None:
+        nonlocal enqueued_count
+        for i in range(50):
+            event = create_sample_message(message_id=str(i))
+            await queue.enqueue_event(event)
+            enqueued_count += 1
+        producer_task_done.set()
+
+    consumed_first = []
+
+    async def consumer_first() -> None:
+        while True:
+            try:
+                event = await queue.dequeue_event()
+                consumed_first.append(event)
+                queue.task_done()
+            except QueueShutDown:
+                break
+
+    consumer_first_task = asyncio.create_task(consumer_first())
+    producer_task = asyncio.create_task(producer())
+
+    # Wait to let the producer fill the queues and confirm it is blocked
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(producer_task_done.wait(), timeout=0.1)
+
+    # Validate that: first consumer receives _TAPPED_QUEUE_SIZE + 1 items.
+    # Other items are blocking trying to be enqueued to second queue.
+    assert len(consumed_first) == _TAPPED_QUEUE_SIZE + 1
+
+    # Validate that: once child queue is blocked, parent will continue
+    # processing other items until it reaches its capacity as well.
+    assert not producer_task.done()
+    assert enqueued_count == _PARENT_QUEUE_SIZE + _TAPPED_QUEUE_SIZE + 1
+
+    consumed_second = []
+
+    # create a consumer for second queue.
+    async def consumer_second() -> None:
+        while True:
+            try:
+                event = await tapped_queue.dequeue_event()
+                consumed_second.append(event)
+                tapped_queue.task_done()
+            except QueueShutDown:
+                break
+
+    consumer_second_task = asyncio.create_task(consumer_second())
+    await asyncio.wait_for(producer_task_done.wait(), timeout=1.0)
+    await queue.close(immediate=False)
+    await asyncio.gather(consumer_first_task, consumer_second_task)
+
+    # Validate that: after unblocking second consumer everything ends smoothly.
+    assert len(consumed_first) == 50
+    assert len(consumed_second) == 50
+
+
+@pytest.mark.asyncio
+async def test_evict_on_full_sink_is_evicted_and_dispatch_continues() -> None:
+    """A full evict_on_full sink is evicted; other sinks keep receiving.
+
+    Regression test for the runtime wedge reported on #1101: one abandoned
+    subscriber sink fills up, the dispatcher's gather blocks on it forever,
+    and no other sink receives anything again.
+    """
+    queue = EventQueueSource()
+    stuck_sink = await queue.tap(max_queue_size=1, evict_on_full=True)
+
+    consumed: list[Event] = []
+
+    async def consume_default() -> None:
+        while True:
+            try:
+                event = await queue.dequeue_event()
+                consumed.append(event)
+                queue.task_done()
+            except QueueShutDown:
+                break
+
+    consumer_task = asyncio.create_task(consume_default())
+
+    # The first event fills the stuck sink (capacity 1, never drained). The
+    # second and third reach the default sink only if the dispatcher
+    # survives the stuck sink.
+    for i in range(3):
+        await queue.enqueue_event(create_sample_message(str(i)))
+
+    async def default_sink_received_all() -> None:
+        while len(consumed) < 3:
+            await asyncio.sleep(0.01)
+
+    await asyncio.wait_for(default_sink_received_all(), timeout=2.0)
+
+    # The stuck sink was evicted: closed and detached from the source.
+    assert stuck_sink.is_closed()
+    assert stuck_sink not in queue._sinks  # noqa: SLF001
+
+    await queue.close(immediate=True)
+    await consumer_task
+
+
+@pytest.mark.asyncio
+async def test_producer_unblocked_after_evict_on_full() -> None:
+    """Producers blocked on a full incoming queue recover after eviction.
+
+    Without eviction, the dispatcher never finishes its gather, the incoming
+    queue stays full, and every producer wedges in enqueue_event permanently.
+    """
+    queue = EventQueueSource(max_queue_size=1, create_default_sink=False)
+    await queue.tap(max_queue_size=1, evict_on_full=True)
+
+    # Sink capacity 1 + incoming capacity 1 both fill, so without eviction
+    # the later enqueues block forever. With eviction the pipeline drains
+    # and every enqueue completes.
+    async def produce() -> None:
+        for i in range(4):
+            await queue.enqueue_event(create_sample_message(str(i)))
+
+    await asyncio.wait_for(produce(), timeout=2.0)
+    await queue.close(immediate=True)
+
+
+@pytest.mark.asyncio
+async def test_default_tap_keeps_backpressure() -> None:
+    """A default tap (evict_on_full=False) preserves blocking dispatch."""
+    queue = EventQueueSource()
+    stuck_sink = await queue.tap(max_queue_size=1)
+
+    for i in range(3):
+        await queue.enqueue_event(create_sample_message(str(i)))
+
+    # Give the dispatcher time to block on the full sink; the sink must
+    # survive and stay attached (flow control, not eviction).
+    await asyncio.sleep(0.3)
+    assert not stuck_sink.is_closed()
+    assert stuck_sink in queue._sinks  # noqa: SLF001
+
+    await queue.close(immediate=True)
+
+
+@pytest.mark.asyncio
+async def test_graceful_close_not_upgraded_to_immediate_by_eviction() -> None:
+    """A sink mid-graceful-close is skipped, never force-closed by eviction.
+
+    ``close(immediate=False)`` marks the sink closed and waits for the
+    consumer to drain the remaining events, but the dispatcher may still
+    hold the sink in an ``active_sinks`` snapshot taken before the close
+    removed it. Delivering to that sink while its queue is full must not
+    trip the evict-on-full path (``close(immediate=True)``), which would
+    discard the events the consumer is still draining.
+    """
+    queue = EventQueueSource()
+    sink = await queue.tap(max_queue_size=1, evict_on_full=True)
+
+    # Fill the sink so the evict-on-full branch would be reachable.
+    await sink._put_internal(create_sample_message('0'))  # noqa: SLF001
+
+    # Start a graceful close: it marks the sink closed, then blocks in
+    # queue.join() until the pending event is consumed.
+    close_task = asyncio.create_task(sink.close(immediate=False))
+    while not sink.is_closed():
+        await asyncio.sleep(0)
+
+    # Simulate the dispatcher delivering from a stale snapshot: the sink
+    # is full and marked closed. It must be skipped, not evicted.
+    await queue._deliver_to_sink(  # noqa: SLF001
+        sink, create_sample_message('1')
+    )
+
+    # The pending event survived the delivery attempt and the consumer
+    # finishes draining, which lets the graceful close complete.
+    event = await sink.dequeue_event()
+    assert isinstance(event, Message)
+    assert event.message_id == '0'
+    sink.task_done()
+    await asyncio.wait_for(close_task, timeout=2.0)
+
+    await queue.close(immediate=True)
diff --git a/tests/server/events/test_inmemory_queue_manager.py b/tests/server/events/test_inmemory_queue_manager.py
new file mode 100644
index 000000000..c24755d68
--- /dev/null
+++ b/tests/server/events/test_inmemory_queue_manager.py
@@ -0,0 +1,173 @@
+import asyncio
+import threading
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from a2a.server.events import InMemoryQueueManager
+from a2a.server.events.event_queue import EventQueueLegacy
+from a2a.server.events.queue_manager import (
+    NoTaskQueue,
+    TaskQueueExists,
+)
+
+
+class TestInMemoryQueueManager:
+    @pytest.fixture
+    def queue_manager(self) -> InMemoryQueueManager:
+        """Fixture to create a fresh InMemoryQueueManager for each test."""
+        return InMemoryQueueManager()
+
+    @pytest.fixture
+    def event_queue(self) -> MagicMock:
+        """Fixture to create a mock EventQueue."""
+        queue = MagicMock(spec=EventQueueLegacy)
+
+        # Mock the tap method to return itself
+        queue.tap.return_value = queue
+        return queue
+
+    @pytest.mark.asyncio
+    async def test_init(self, queue_manager: InMemoryQueueManager) -> None:
+        """Test that the InMemoryQueueManager initializes with empty task queue and a lock."""
+        assert queue_manager._task_queue == {}
+        assert not isinstance(queue_manager._lock, asyncio.Lock)
+        assert isinstance(queue_manager._lock, type(threading.RLock()))
+
+    @pytest.mark.asyncio
+    async def test_add_new_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test adding a new queue to the manager."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+        assert queue_manager._task_queue[task_id] == event_queue
+
+    @pytest.mark.asyncio
+    async def test_add_existing_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test adding a queue with an existing task_id raises TaskQueueExists."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+
+        with pytest.raises(TaskQueueExists):
+            await queue_manager.add(task_id, event_queue)
+
+    @pytest.mark.asyncio
+    async def test_get_existing_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test getting an existing queue returns the queue."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+
+        result = await queue_manager.get(task_id)
+        assert result == event_queue
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent_queue(
+        self, queue_manager: InMemoryQueueManager
+    ) -> None:
+        """Test getting a nonexistent queue returns None."""
+        result = await queue_manager.get('nonexistent_task_id')
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_tap_existing_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test tapping an existing queue returns the tapped queue."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+
+        result = await queue_manager.tap(task_id)
+        assert result == event_queue
+        event_queue.tap.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_tap_nonexistent_queue(
+        self, queue_manager: InMemoryQueueManager
+    ) -> None:
+        """Test tapping a nonexistent queue returns None."""
+        result = await queue_manager.tap('nonexistent_task_id')
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_close_existing_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test closing an existing queue removes it from the manager."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+
+        await queue_manager.close(task_id)
+        assert task_id not in queue_manager._task_queue
+
+    @pytest.mark.asyncio
+    async def test_close_nonexistent_queue(
+        self, queue_manager: InMemoryQueueManager
+    ) -> None:
+        """Test closing a nonexistent queue raises NoTaskQueue."""
+        with pytest.raises(NoTaskQueue):
+            await queue_manager.close('nonexistent_task_id')
+
+    @pytest.mark.asyncio
+    async def test_create_or_tap_new_queue(
+        self, queue_manager: InMemoryQueueManager
+    ) -> None:
+        """Test create_or_tap with a new task_id creates and returns a new queue."""
+        task_id = 'test_task_id'
+
+        result = await queue_manager.create_or_tap(task_id)
+        assert isinstance(result, EventQueueLegacy)
+        assert queue_manager._task_queue[task_id] == result
+
+    @pytest.mark.asyncio
+    async def test_create_or_tap_existing_queue(
+        self, queue_manager: InMemoryQueueManager, event_queue: MagicMock
+    ) -> None:
+        """Test create_or_tap with an existing task_id taps and returns the existing queue."""
+        task_id = 'test_task_id'
+        await queue_manager.add(task_id, event_queue)
+
+        result = await queue_manager.create_or_tap(task_id)
+
+        assert result == event_queue
+        event_queue.tap.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_concurrency(
+        self, queue_manager: InMemoryQueueManager
+    ) -> None:
+        """Test concurrent access to the queue manager."""
+
+        async def add_task(task_id):
+            queue = EventQueueLegacy()
+            await queue_manager.add(task_id, queue)
+            return task_id
+
+        async def get_task(task_id):
+            return await queue_manager.get(task_id)
+
+        # Create 10 different task IDs
+        task_ids = [f'task_{i}' for i in range(10)]
+
+        # Add tasks concurrently
+        add_tasks = [add_task(task_id) for task_id in task_ids]
+        added_task_ids = await asyncio.gather(*add_tasks)
+
+        # Verify all tasks were added
+        assert set(added_task_ids) == set(task_ids)
+
+        # Get tasks concurrently
+        get_tasks = [get_task(task_id) for task_id in task_ids]
+        queues = await asyncio.gather(*get_tasks)
+
+        # Verify all queues are not None
+        assert all(queue is not None for queue in queues)
+
+        # Verify all tasks are in the manager
+        for task_id in task_ids:
+            assert task_id in queue_manager._task_queue
diff --git a/tests/server/request_handlers/__init__.py b/tests/server/request_handlers/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/request_handlers/test_default_request_handler.py b/tests/server/request_handlers/test_default_request_handler.py
new file mode 100644
index 000000000..aac984b72
--- /dev/null
+++ b/tests/server/request_handlers/test_default_request_handler.py
@@ -0,0 +1,3603 @@
+import asyncio
+import contextlib
+import logging
+import time
+import uuid
+
+from typing import cast
+from unittest.mock import (
+    AsyncMock,
+    MagicMock,
+    PropertyMock,
+    patch,
+)
+
+import pytest
+
+from a2a.auth.user import UnauthenticatedUser, User
+from a2a.helpers.proto_helpers import (
+    new_task_from_user_message,
+    new_text_message,
+)
+from a2a.server.agent_execution import (
+    AgentExecutor,
+    RequestContext,
+    RequestContextBuilder,
+    SimpleRequestContextBuilder,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.events import (
+    EventQueue,
+    EventQueueLegacy,
+    InMemoryQueueManager,
+    QueueManager,
+)
+from a2a.server.request_handlers import (
+    LegacyRequestHandler as DefaultRequestHandler,
+)
+from a2a.server.tasks import (
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+    PushNotificationConfigStore,
+    PushNotificationSender,
+    ResultAggregator,
+    TaskStore,
+    TaskUpdater,
+)
+from a2a.types import (
+    ContentTypeNotSupportedError,
+    InternalError,
+    InvalidParamsError,
+    PushNotificationNotSupportedError,
+    TaskNotCancelableError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Artifact,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetExtendedAgentCardRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import TERMINAL_TASK_STATES
+from a2a.utils.push_url_validator import (
+    validate_push_notification_url,
+)
+
+
+class MockAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task_updater = TaskUpdater(
+            event_queue,
+            context.task_id,  # type: ignore[arg-type]
+            context.context_id,  # type: ignore[arg-type]
+        )
+        async for i in self._run():
+            parts = [Part(text=f'Event {i}')]
+            try:
+                await task_updater.update_status(
+                    TaskState.TASK_STATE_WORKING,
+                    message=task_updater.new_agent_message(parts),
+                )
+            except RuntimeError:
+                # Stop processing when the event loop is closed
+                break
+
+    async def _run(self):
+        for i in range(1_000_000):  # Simulate a long-running stream
+            yield i
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+# Helper to create a simple task for tests
+def create_sample_task(
+    task_id='task1',
+    status_state=TaskState.TASK_STATE_SUBMITTED,
+    context_id='ctx1',
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=status_state),
+    )
+
+
+# Helper to create ServerCallContext
+def create_server_call_context() -> ServerCallContext:
+    # Assuming UnauthenticatedUser is available or can be imported
+
+    return ServerCallContext(user=UnauthenticatedUser())
+
+
+@pytest.fixture
+def agent_card():
+    """Provides a standard AgentCard with streaming and push notifications enabled for tests."""
+    return AgentCard(
+        name='test_agent',
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+    )
+
+
+def test_init_default_dependencies(agent_card):
+    """Test that default dependencies are created if not provided."""
+    agent_executor = MockAgentExecutor()
+    task_store = InMemoryTaskStore()
+
+    handler = DefaultRequestHandler(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        agent_card=agent_card,
+    )
+
+    assert isinstance(handler._queue_manager, InMemoryQueueManager)
+    assert isinstance(
+        handler._request_context_builder, SimpleRequestContextBuilder
+    )
+    assert handler._push_config_store is None
+    assert handler._push_sender is None
+    assert (
+        handler._request_context_builder._should_populate_referred_tasks
+        is False
+    )
+    assert handler._request_context_builder._task_store == task_store
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_not_found(agent_card):
+    """Test on_get_task when task_store.get returns None."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    params = GetTaskRequest(id='non_existent_task')
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task(params, context)
+
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_success(agent_card):
+    """Test on_list_tasks successfully returns a page of tasks ."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    task2 = create_sample_task(task_id='task2')
+    task2.artifacts.extend(
+        [
+            Artifact(
+                artifact_id='artifact1',
+                parts=[Part(text='Hello world!')],
+                name='conversion_result',
+            )
+        ]
+    )
+    mock_page = ListTasksResponse(
+        tasks=[
+            create_sample_task(task_id='task1'),
+            task2,
+        ],
+        next_page_token='123',
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(include_artifacts=True, page_size=10)
+    context = create_server_call_context()
+
+    result = await request_handler.on_list_tasks(params, context)
+
+    mock_task_store.list.assert_awaited_once_with(params, context)
+    assert result.tasks == mock_page.tasks
+    assert result.next_page_token == mock_page.next_page_token
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_excludes_artifacts(agent_card):
+    """Test on_list_tasks excludes artifacts from returned tasks."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    task2 = create_sample_task(task_id='task2')
+    task2.artifacts.extend(
+        [
+            Artifact(
+                artifact_id='artifact1',
+                parts=[Part(text='Hello world!')],
+                name='conversion_result',
+            )
+        ]
+    )
+    mock_page = ListTasksResponse(
+        tasks=[
+            create_sample_task(task_id='task1'),
+            task2,
+        ],
+        next_page_token='123',
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(include_artifacts=False, page_size=10)
+    context = create_server_call_context()
+
+    result = await request_handler.on_list_tasks(params, context)
+
+    assert not result.tasks[1].artifacts
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_applies_history_length(agent_card):
+    """Test on_list_tasks applies history length filter."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    history = [
+        new_text_message('Hello 1!'),
+        new_text_message('Hello 2!'),
+    ]
+    task2 = create_sample_task(task_id='task2')
+    task2.history.extend(history)
+    mock_page = ListTasksResponse(
+        tasks=[
+            create_sample_task(task_id='task1'),
+            task2,
+        ],
+        next_page_token='123',
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(history_length=1, page_size=10)
+    context = create_server_call_context()
+
+    result = await request_handler.on_list_tasks(params, context)
+
+    assert result.tasks[1].history == [history[1]]
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_negative_history_length_error(agent_card):
+    """Test on_list_tasks raises error for negative history length."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(history_length=-1, page_size=10)
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_task_not_found():
+    """Test on_cancel_task when the task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = CancelTaskRequest(id='task_not_found_for_cancel')
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_cancel_task(params, context)
+
+    mock_task_store.get.assert_awaited_once_with(
+        'task_not_found_for_cancel', context
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_queue_tap_returns_none(agent_card):
+    """Test on_cancel_task when queue_manager.tap returns None."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='tap_none_task')
+    mock_task_store.get.return_value = sample_task
+
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_queue_manager.tap.return_value = (
+        None  # Simulate queue not found / tap returns None
+    )
+
+    mock_agent_executor = AsyncMock(
+        spec=AgentExecutor
+    )  # Use AsyncMock for agent_executor
+
+    # Mock ResultAggregator and its consume_all method
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_all.return_value = (
+        create_sample_task(
+            task_id='tap_none_task',
+            status_state=TaskState.TASK_STATE_CANCELED,  # Expected final state
+        )
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+
+    context = create_server_call_context()
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+        return_value=mock_result_aggregator_instance,
+    ):
+        params = CancelTaskRequest(id='tap_none_task')
+        result_task = await request_handler.on_cancel_task(params, context)
+
+    mock_task_store.get.assert_awaited_once_with('tap_none_task', context)
+    mock_queue_manager.tap.assert_awaited_once_with('tap_none_task')
+    # agent_executor.cancel should be called with a new EventQueue if tap returned None
+    mock_agent_executor.cancel.assert_awaited_once()
+    # Verify the EventQueue passed to cancel was a new one
+    call_args_list = mock_agent_executor.cancel.call_args_list
+    args, _ = call_args_list[0]
+    assert isinstance(
+        args[1], EventQueue
+    )  # args[1] is the event_queue argument
+
+    mock_result_aggregator_instance.consume_all.assert_awaited_once()
+    assert result_task is not None
+    assert result_task.status.state == TaskState.TASK_STATE_CANCELED
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_cancels_running_agent(agent_card):
+    """Test on_cancel_task cancels a running agent task."""
+    task_id = 'running_agent_task_to_cancel'
+    sample_task = create_sample_task(task_id=task_id)
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = sample_task
+
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_event_queue = AsyncMock(spec=EventQueueLegacy)
+    mock_queue_manager.tap.return_value = mock_event_queue
+
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+
+    # Mock ResultAggregator
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_all.return_value = (
+        create_sample_task(
+            task_id=task_id, status_state=TaskState.TASK_STATE_CANCELED
+        )
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+
+    # Simulate a running agent task
+    mock_producer_task = AsyncMock(spec=asyncio.Task)
+    request_handler._running_agents[task_id] = mock_producer_task
+
+    context = create_server_call_context()
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+        return_value=mock_result_aggregator_instance,
+    ):
+        params = CancelTaskRequest(
+            id=f'{task_id}',
+            metadata={'reason': 'user_aborted'},
+        )
+        await request_handler.on_cancel_task(params, context)
+
+    mock_producer_task.cancel.assert_called_once()
+    mock_agent_executor.cancel.assert_awaited_once()
+    cancel_ctx: RequestContext = mock_agent_executor.cancel.call_args.args[0]
+    assert cancel_ctx.metadata == {'reason': 'user_aborted'}
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_completes_during_cancellation(agent_card):
+    """Test on_cancel_task fails to cancel a task due to concurrent task completion."""
+    task_id = 'running_agent_task_to_cancel'
+    sample_task = create_sample_task(task_id=task_id)
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = sample_task
+
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_event_queue = AsyncMock(spec=EventQueueLegacy)
+    mock_queue_manager.tap.return_value = mock_event_queue
+
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+
+    # Mock ResultAggregator
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_all.return_value = (
+        create_sample_task(
+            task_id=task_id, status_state=TaskState.TASK_STATE_COMPLETED
+        )
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+
+    # Simulate a running agent task
+    mock_producer_task = AsyncMock(spec=asyncio.Task)
+    request_handler._running_agents[task_id] = mock_producer_task
+
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+        return_value=mock_result_aggregator_instance,
+    ):
+        params = CancelTaskRequest(id=f'{task_id}')
+        with pytest.raises(
+            TaskNotCancelableError,
+            match='current state: TASK_STATE_COMPLETED',
+        ):
+            await request_handler.on_cancel_task(
+                params, create_server_call_context()
+            )
+
+    mock_producer_task.cancel.assert_called_once()
+    mock_agent_executor.cancel.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_already_terminal_names_state(agent_card):
+    """Cancelling a finished task reports the state by name."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = create_sample_task(
+        task_id='finished_task', status_state=TaskState.TASK_STATE_FAILED
+    )
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    with pytest.raises(
+        TaskNotCancelableError, match='current state: TASK_STATE_FAILED'
+    ):
+        await request_handler.on_cancel_task(
+            CancelTaskRequest(id='finished_task'), create_server_call_context()
+        )
+
+    mock_agent_executor.cancel.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_invalid_result_type(agent_card):
+    """Test on_cancel_task when result_aggregator returns a Message instead of a Task."""
+    task_id = 'cancel_invalid_result_task'
+    sample_task = create_sample_task(task_id=task_id)
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = sample_task
+
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_event_queue = AsyncMock(spec=EventQueueLegacy)
+    mock_queue_manager.tap.return_value = mock_event_queue
+
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+
+    # Mock ResultAggregator to return a Message
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_all.return_value = Message(
+        message_id='unexpected_msg',
+        role=Role.ROLE_AGENT,
+        parts=[Part(text='Test')],
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+        return_value=mock_result_aggregator_instance,
+    ):
+        params = CancelTaskRequest(id=f'{task_id}')
+        with pytest.raises(InternalError) as exc_info:
+            await request_handler.on_cancel_task(
+                params, create_server_call_context()
+            )
+
+    assert (
+        'Agent did not return valid response for cancel'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_with_push_notification(agent_card):
+    """Test on_message_send sets push notification info if provided."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_push_notification_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'push_task_1'
+    context_id = 'push_ctx_1'
+    sample_initial_task = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_SUBMITTED,
+    )
+
+    # TaskManager will be created inside on_message_send.
+    # We need to mock task_store.get to return None initially for TaskManager to create a new task.
+    # Then, TaskManager.update_with_message will be called.
+    # For simplicity in this unit test, let's assume TaskManager correctly sets up the task
+    # and the task object (with IDs) is available for _request_context_builder.build
+
+    mock_task_store.get.return_value = (
+        None  # Simulate new task scenario for TaskManager
+    )
+
+    # Mock _request_context_builder.build to return a context with the generated/confirmed IDs
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        push_config_store=mock_push_notification_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+
+    push_config = TaskPushNotificationConfig(url='http://example.com/push')
+    message_config = SendMessageConfiguration(
+        task_push_notification_config=push_config,
+        accepted_output_modes=['text/plain'],  # Added required field
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        ),
+        configuration=message_config,
+    )
+
+    # Mock ResultAggregator and its consume_and_break_on_interrupt
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    final_task_result = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_COMPLETED,
+    )
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        final_task_result,
+        False,
+        None,
+    )
+
+    # Mock the current_result async property to return the final task result
+    # current_result is an async property, so accessing it returns a coroutine
+    async def mock_current_result():
+        return final_task_result
+
+    type(mock_result_aggregator_instance).current_result = property(
+        lambda self: mock_current_result()
+    )
+
+    context = create_server_call_context()
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=sample_initial_task,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.update_with_message',
+            return_value=sample_initial_task,
+        ),
+    ):  # Ensure task object is returned
+        await request_handler.on_message_send(params, context)
+
+    mock_push_notification_store.set_info.assert_awaited_once_with(
+        task_id, push_config, context
+    )
+    # Other assertions for full flow if needed (e.g., agent execution)
+    mock_agent_executor.execute.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_with_push_notification_in_non_blocking_request(
+    agent_card,
+):
+    """Test that push notification callback is called during background event processing for non-blocking requests."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_push_notification_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+    mock_push_sender = AsyncMock()
+
+    task_id = 'non_blocking_task_1'
+    context_id = 'non_blocking_ctx_1'
+
+    # Create a task that will be returned after the first event
+    initial_task = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_WORKING,
+    )
+
+    # Create a final task that will be available during background processing
+    final_task = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_COMPLETED,
+    )
+
+    mock_task_store.get.return_value = None
+
+    # Mock request context
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        push_config_store=mock_push_notification_store,
+        request_context_builder=mock_request_context_builder,
+        push_sender=mock_push_sender,
+        agent_card=agent_card,
+    )
+
+    # Configure push notification
+    push_config = TaskPushNotificationConfig(url='http://example.com/push')
+    message_config = SendMessageConfiguration(
+        task_push_notification_config=push_config,
+        accepted_output_modes=['text/plain'],
+        return_immediately=True,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_non_blocking',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        ),
+        configuration=message_config,
+    )
+
+    # Mock ResultAggregator with custom behavior
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+
+    # First call returns the initial task and indicates interruption (non-blocking)
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        initial_task,
+        True,  # interrupted = True for non-blocking
+        MagicMock(spec=asyncio.Task),  # background task
+    )
+
+    # Mock the current_result async property to return the final task
+    # current_result is an async property, so accessing it returns a coroutine
+    async def mock_current_result():
+        return final_task
+
+    type(mock_result_aggregator_instance).current_result = property(
+        lambda self: mock_current_result()
+    )
+
+    # Track if the event_callback was passed to consume_and_break_on_interrupt
+    event_callback_passed = False
+    event_callback_received = None
+
+    async def mock_consume_and_break_on_interrupt(
+        consumer, blocking=True, event_callback=None
+    ):
+        nonlocal event_callback_passed, event_callback_received
+        event_callback_passed = event_callback is not None
+        event_callback_received = event_callback
+        if event_callback_received:
+            await event_callback_received(final_task)
+        return (
+            initial_task,
+            True,
+            MagicMock(spec=asyncio.Task),
+        )  # interrupted = True for non-blocking
+
+    mock_result_aggregator_instance.consume_and_break_on_interrupt = (
+        mock_consume_and_break_on_interrupt
+    )
+
+    context = create_server_call_context()
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=initial_task,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.update_with_message',
+            return_value=initial_task,
+        ),
+    ):
+        # Execute the non-blocking request
+        result = await request_handler.on_message_send(params, context)
+
+    # Verify the result is the initial task (non-blocking behavior)
+    assert result == initial_task
+
+    # Verify that the event_callback was passed to consume_and_break_on_interrupt
+    assert event_callback_passed, (
+        'event_callback should have been passed to consume_and_break_on_interrupt'
+    )
+    assert event_callback_received is not None, (
+        'event_callback should not be None'
+    )
+
+    # Verify that the push notification was sent with the final task
+    mock_push_sender.send_notification.assert_called_with(task_id, final_task)
+
+    # Verify that the push notification config was stored
+    mock_push_notification_store.set_info.assert_awaited_once_with(
+        task_id, push_config, context
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_with_push_notification_no_existing_Task(
+    agent_card,
+):
+    """Test on_message_send for new task sets push notification info if provided."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_push_notification_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'push_task_1'
+    context_id = 'push_ctx_1'
+
+    mock_task_store.get.return_value = (
+        None  # Simulate new task scenario for TaskManager
+    )
+
+    # Mock _request_context_builder.build to return a context with the generated/confirmed IDs
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        push_config_store=mock_push_notification_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+
+    push_config = TaskPushNotificationConfig(url='http://example.com/push')
+    message_config = SendMessageConfiguration(
+        task_push_notification_config=push_config,
+        accepted_output_modes=['text/plain'],  # Added required field
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Test')],
+        ),
+        configuration=message_config,
+    )
+
+    # Mock ResultAggregator and its consume_and_break_on_interrupt
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    final_task_result = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_COMPLETED,
+    )
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        final_task_result,
+        False,
+        None,
+    )
+
+    # Mock the current_result async property to return the final task result
+    # current_result is an async property, so accessing it returns a coroutine
+    async def mock_current_result():
+        return final_task_result
+
+    type(mock_result_aggregator_instance).current_result = property(
+        lambda self: mock_current_result()
+    )
+
+    context = create_server_call_context()
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):
+        await request_handler.on_message_send(params, context)
+
+    mock_push_notification_store.set_info.assert_awaited_once_with(
+        task_id, push_config, context
+    )
+    # Other assertions for full flow if needed (e.g., agent execution)
+    mock_agent_executor.execute.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_no_result_from_aggregator(agent_card):
+    """Test on_message_send when aggregator returns (None, False). Completes unsuccessfully and raises InternalError."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'no_result_task'
+    # Mock _request_context_builder.build
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_no_res',
+            parts=[Part(text='Test')],
+        )
+    )
+
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        None,
+        False,
+        None,
+    )
+
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):  # TaskManager.get_task for initial task
+        with pytest.raises(InternalError):
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_task_id_mismatch(agent_card):
+    """Test on_message_send returns InternalError if aggregator returns mismatched Task ID."""
+    """Test on_message_send when result task ID doesn't match request context task ID."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    context_task_id = 'context_task_id_1'
+    result_task_id = 'DIFFERENT_task_id_1'  # Mismatch
+
+    # Mock _request_context_builder.build
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = context_task_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_id_mismatch',
+            parts=[Part(text='Test')],
+        )
+    )
+
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mismatched_task = create_sample_task(task_id=result_task_id)
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        mismatched_task,
+        False,
+        None,
+    )
+
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):
+        with pytest.raises(InternalError) as exc_info:
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+
+    assert 'Task ID mismatch' in exc_info.value.message  # type: ignore
+
+
+class HelloAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = context.current_task
+        if not task:
+            assert context.message is not None, (
+                'A message is required to create a new task'
+            )
+            task = new_task_from_user_message(context.message)  # type: ignore
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+
+        try:
+            parts = [Part(text='I am working')]
+            await updater.update_status(
+                TaskState.TASK_STATE_WORKING,
+                message=updater.new_agent_message(parts),
+            )
+        except Exception as e:
+            # Stop processing when the event loop is closed
+            logging.warning('Error: %s', e)
+            return
+        await updater.add_artifact(
+            [Part(text='Hello world!')],
+            name='conversion_result',
+        )
+        await updater.complete()
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('validate_input_modes', 'expect_rejection'), [(True, True), (False, False)]
+)
+async def test_on_message_send_input_mode_validation_is_opt_in(
+    validate_input_modes, expect_rejection
+):
+    """The legacy handler gates the same check behind the same flag."""
+    request_handler = DefaultRequestHandler(
+        agent_executor=HelloAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=AgentCard(
+            name='test_agent',
+            version='1.0',
+            capabilities=AgentCapabilities(streaming=True),
+            default_input_modes=['text/plain'],
+        ),
+        validate_input_modes=validate_input_modes,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_bad_media_type',
+            parts=[Part(text='hello', media_type='application/x-nope')],
+        )
+    )
+
+    if expect_rejection:
+        with pytest.raises(ContentTypeNotSupportedError):
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+    else:
+        assert (
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+            is not None
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_non_blocking(agent_card):
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            return_immediately=True, accepted_output_modes=['text/plain']
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    assert result is not None
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_SUBMITTED
+
+    # Polling for 500ms until task is completed.
+    task: Task | None = None
+    for _ in range(5):
+        await asyncio.sleep(0.1)
+        task = await task_store.get(result.id, context)
+        assert task is not None
+        if task.status.state == TaskState.TASK_STATE_COMPLETED:
+            break
+
+    assert task is not None
+    assert task.status.state == TaskState.TASK_STATE_COMPLETED
+    # The result is the task as it was returned, with its whole history; the
+    # agent's later status messages are added to the stored task only.
+    assert result.history
+    assert list(task.history[: len(result.history)]) == list(result.history)
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_limit_history(agent_card):
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain'],
+            history_length=1,
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    # verify that history_length is honored
+    assert result is not None
+    assert isinstance(result, Task)
+    assert result.history is not None and len(result.history) == 1
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+
+    # verify that history is still persisted to the store
+    task = await task_store.get(result.id, context)
+    assert task is not None
+    assert task.history is not None and len(task.history) > 1
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_limit_history(agent_card):
+    task_store = InMemoryTaskStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_stream',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain'],
+            history_length=0,
+        ),
+    )
+
+    context = create_server_call_context()
+    tasks = [
+        event
+        async for event in request_handler.on_message_send_stream(
+            params, context
+        )
+        if isinstance(event, Task)
+    ]
+
+    # verify that history_length is honored
+    assert tasks
+    assert all(len(task.history) == 0 for task in tasks)
+
+    # verify that history is still persisted to the store
+    task = await task_store.get(tasks[0].id, context)
+    assert task is not None
+    assert len(task.history) > 0
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_limit_history(agent_card):
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain'],
+        ),
+    )
+
+    result = await request_handler.on_message_send(
+        params, create_server_call_context()
+    )
+
+    assert result is not None
+    assert isinstance(result, Task)
+
+    get_task_result = await request_handler.on_get_task(
+        GetTaskRequest(id=result.id, history_length=1),
+        create_server_call_context(),
+    )
+    assert get_task_result is not None
+    assert isinstance(get_task_result, Task)
+    assert (
+        get_task_result.history is not None
+        and len(get_task_result.history) == 1
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_interrupted_flow(agent_card):
+    """Test on_message_send when flow is interrupted (e.g., auth_required)."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'interrupted_task_1'
+    # Mock _request_context_builder.build
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_interrupt',
+            parts=[Part(text='Test')],
+        )
+    )
+
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    interrupt_task_result = create_sample_task(
+        task_id=task_id, status_state=TaskState.TASK_STATE_AUTH_REQUIRED
+    )
+    mock_result_aggregator_instance.consume_and_break_on_interrupt.return_value = (
+        interrupt_task_result,
+        True,
+        MagicMock(spec=asyncio.Task),  # background task
+    )  # Interrupted = True
+
+    # Collect coroutines passed to create_task so we can close them
+    created_coroutines = []
+
+    def capture_create_task(coro):
+        created_coroutines.append(coro)
+        return MagicMock()
+
+    # Patch asyncio.create_task to verify _cleanup_producer is scheduled
+    with (
+        patch(
+            'asyncio.create_task', side_effect=capture_create_task
+        ) as mock_asyncio_create_task,
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):
+        result = await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+
+    assert result == interrupt_task_result
+    assert (
+        mock_asyncio_create_task.call_count == 2
+    )  # First for _run_event_stream, second for _cleanup_producer
+
+    # Check that the second call to create_task was for _cleanup_producer
+    found_cleanup_call = False
+    for coro in created_coroutines:
+        if hasattr(coro, '__name__') and coro.__name__ == '_cleanup_producer':
+            found_cleanup_call = True
+            break
+    assert found_cleanup_call, (
+        '_cleanup_producer was not scheduled with asyncio.create_task'
+    )
+
+    # Close coroutines to avoid RuntimeWarning about unawaited coroutines
+    for coro in created_coroutines:
+        coro.close()
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_with_push_notification(agent_card):
+    """Test on_message_send_stream sets and uses push notification info."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_push_config_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_push_sender = AsyncMock(spec=PushNotificationSender)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'stream_push_task_1'
+    context_id = 'stream_push_ctx_1'
+
+    # Initial task state for TaskManager
+    initial_task_for_tm = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_SUBMITTED,
+    )
+
+    # Task state for RequestContext
+    task_for_rc = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_WORKING,
+    )  # Example state after message update
+
+    mock_task_store.get.return_value = None  # New task for TaskManager
+
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        push_config_store=mock_push_config_store,
+        push_sender=mock_push_sender,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+
+    push_config = TaskPushNotificationConfig(url='http://example.com/push')
+    message_config = SendMessageConfiguration(
+        task_push_notification_config=push_config,
+        accepted_output_modes=['text/plain'],  # Added required field
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_stream_push',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        ),
+        configuration=message_config,
+    )
+
+    # Latch to ensure background execute is scheduled before asserting
+    execute_called = asyncio.Event()
+
+    async def exec_side_effect(*args, **kwargs):
+        execute_called.set()
+
+    mock_agent_executor.execute.side_effect = exec_side_effect
+
+    # Mock ResultAggregator and its consume_and_emit
+    mock_result_aggregator_instance = MagicMock(
+        spec=ResultAggregator
+    )  # Use MagicMock for easier property mocking
+
+    # Events to be yielded by consume_and_emit
+    event1_task_update = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_WORKING,
+    )
+    event2_final_task = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_COMPLETED,
+    )
+
+    async def event_stream_gen():
+        yield event1_task_update
+        yield event2_final_task
+
+    # consume_and_emit is called by `async for ... in result_aggregator.consume_and_emit(consumer)`
+    # This means result_aggregator.consume_and_emit(consumer) must directly return an async iterable.
+    # If consume_and_emit is an async method, this is problematic in the product code.
+    # For the test, we make the mock of consume_and_emit a synchronous method
+    # that returns the async generator object.
+    def sync_get_event_stream_gen(*args, **kwargs):
+        return event_stream_gen()
+
+    mock_result_aggregator_instance.consume_and_emit = MagicMock(
+        side_effect=sync_get_event_stream_gen
+    )
+
+    # Mock current_result as an async property returning events sequentially.
+    async def to_coro(val):
+        return val
+
+    type(mock_result_aggregator_instance).current_result = PropertyMock(
+        side_effect=[to_coro(event1_task_update), to_coro(event2_final_task)]
+    )
+
+    context = create_server_call_context()
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=initial_task_for_tm,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.update_with_message',
+            return_value=task_for_rc,
+        ),
+    ):
+        # Consume the stream
+        async for _ in request_handler.on_message_send_stream(params, context):
+            pass
+
+    await asyncio.wait_for(execute_called.wait(), timeout=0.1)
+
+    # Assertions
+    # 1. set_info called once at the beginning if task exists (or after task is created from message)
+    mock_push_config_store.set_info.assert_any_call(
+        task_id, push_config, context
+    )
+
+    # 2. send_notification called for each task event yielded by aggregator
+    assert mock_push_sender.send_notification.await_count == 2
+    mock_push_sender.send_notification.assert_any_await(
+        task_id, event1_task_update
+    )
+    mock_push_sender.send_notification.assert_any_await(
+        task_id, event2_final_task
+    )
+
+    mock_agent_executor.execute.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_stream_disconnect_then_resubscribe_receives_future_events(
+    agent_card,
+):
+    """Start streaming, disconnect, then resubscribe and ensure subsequent events are streamed."""
+    # Arrange
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+
+    # Use a real queue manager so taps receive future events
+    queue_manager = InMemoryQueueManager()
+
+    task_id = 'reconn_task_1'
+    context_id = 'reconn_ctx_1'
+
+    # Task exists and is non-final
+    task_for_resub = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_WORKING,
+    )
+    mock_task_store.get.return_value = task_for_resub
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=queue_manager,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_reconn',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        )
+    )
+
+    # Producer behavior: emit one event, then later emit second event
+    exec_started = asyncio.Event()
+    allow_second_event = asyncio.Event()
+    allow_finish = asyncio.Event()
+
+    first_event = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_WORKING,
+    )
+    second_event = create_sample_task(
+        task_id=task_id,
+        context_id=context_id,
+        status_state=TaskState.TASK_STATE_COMPLETED,
+    )
+
+    async def exec_side_effect(_request, queue: EventQueue):
+        exec_started.set()
+        await queue.enqueue_event(first_event)
+        await allow_second_event.wait()
+        await queue.enqueue_event(second_event)
+        await allow_finish.wait()
+
+    mock_agent_executor.execute.side_effect = exec_side_effect
+
+    # Start streaming and consume first event
+    agen = request_handler.on_message_send_stream(
+        params, create_server_call_context()
+    )
+    first = await agen.__anext__()
+    assert first == first_event
+
+    # Simulate client disconnect
+    await asyncio.wait_for(agen.aclose(), timeout=0.1)
+
+    # Resubscribe and start consuming future events
+    resub_gen = request_handler.on_subscribe_to_task(
+        SubscribeToTaskRequest(id=f'{task_id}'),
+        create_server_call_context(),
+    )
+
+    # Allow producer to emit the next event
+    allow_second_event.set()
+
+    first_subscribe_event = await anext(resub_gen)
+    assert first_subscribe_event == task_for_resub
+
+    received = await anext(resub_gen)
+    assert received == second_event
+
+    # Finish producer to allow cleanup paths to complete
+    allow_finish.set()
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_client_disconnect_triggers_background_cleanup_and_producer_continues(
+    agent_card,
+):
+    """Simulate client disconnect: stream stops early, cleanup is scheduled in background,
+    producer keeps running, and cleanup completes after producer finishes."""
+    # Arrange
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'disc_task_1'
+    context_id = 'disc_ctx_1'
+
+    # Return an existing task from the store to avoid "task not found" error
+    existing_task = create_sample_task(task_id=task_id, context_id=context_id)
+    mock_task_store.get.return_value = existing_task
+
+    # RequestContext with IDs
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    # Queue used by _run_event_stream; must support close()
+    mock_queue = AsyncMock(spec=EventQueueLegacy)
+    mock_queue_manager.create_or_tap.return_value = mock_queue
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='mid',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        )
+    )
+
+    # Agent executor runs in background until we allow it to finish
+    execute_started = asyncio.Event()
+    execute_finish = asyncio.Event()
+
+    async def exec_side_effect(*_args, **_kwargs):
+        execute_started.set()
+        await execute_finish.wait()
+
+    mock_agent_executor.execute.side_effect = exec_side_effect
+
+    # ResultAggregator emits one Task event (so the stream yields once)
+    first_event = create_sample_task(task_id=task_id, context_id=context_id)
+
+    async def single_event_stream():
+        yield first_event
+        # will never yield again; client will disconnect
+
+    mock_result_aggregator_instance = MagicMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_and_emit.return_value = (
+        single_event_stream()
+    )
+    # Signal when background consume_all is started
+    bg_started = asyncio.Event()
+
+    async def mock_consume_all(_consumer):
+        bg_started.set()
+        # emulate short-running background work
+        await asyncio.sleep(0)
+
+    mock_result_aggregator_instance.consume_all = mock_consume_all
+
+    produced_task: asyncio.Task | None = None
+    cleanup_task: asyncio.Task | None = None
+
+    orig_create_task = asyncio.create_task
+
+    def create_task_spy(coro):
+        nonlocal produced_task, cleanup_task
+        task = orig_create_task(coro)
+        # Inspect the coroutine name to make the spy more robust
+        if coro.__name__ == '_run_event_stream':
+            produced_task = task
+        elif coro.__name__ == '_cleanup_producer':
+            cleanup_task = task
+        return task
+
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch('asyncio.create_task', side_effect=create_task_spy),
+    ):
+        # Act: start stream and consume only the first event, then disconnect
+        agen = request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        )
+        first = await agen.__anext__()
+        assert first == first_event
+        # Simulate client disconnect
+        await asyncio.wait_for(agen.aclose(), timeout=0.1)
+
+    # Assert cleanup was scheduled and producer was started
+    assert produced_task is not None
+    assert cleanup_task is not None
+
+    # Assert background consume_all started
+    await asyncio.wait_for(bg_started.wait(), timeout=0.2)
+
+    # execute should have started
+    await asyncio.wait_for(execute_started.wait(), timeout=0.1)
+
+    # Producer should still be running (not finished immediately on disconnect)
+    assert not produced_task.done()
+
+    # Allow executor to finish, which should complete producer and then cleanup
+    execute_finish.set()
+    await asyncio.wait_for(produced_task, timeout=0.2)
+    await asyncio.wait_for(cleanup_task, timeout=0.2)
+
+    # Queue close awaited by _run_event_stream
+    mock_queue.close.assert_awaited_once()
+    # QueueManager close called by _cleanup_producer
+    mock_queue_manager.close.assert_awaited_once_with(task_id)
+    # Running agents is cleared
+    assert task_id not in request_handler._running_agents
+
+    # Cleanup any lingering background tasks started by on_message_send_stream
+    # (e.g., background_consume)
+    for t in list(request_handler._background_tasks):
+        t.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await t
+
+
+@pytest.mark.asyncio
+async def test_disconnect_persists_final_task_to_store(agent_card):
+    """After client disconnect, ensure background consumer persists final Task to store."""
+    task_store = InMemoryTaskStore()
+    queue_manager = InMemoryQueueManager()
+
+    # Custom agent that emits a working update then a completed final update
+    class FinishingAgent(AgentExecutor):
+        def __init__(self):
+            self.allow_finish = asyncio.Event()
+
+        async def execute(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            updater = TaskUpdater(
+                event_queue,
+                cast('str', context.task_id),
+                cast('str', context.context_id),
+            )
+            await updater.update_status(TaskState.TASK_STATE_WORKING)
+            await self.allow_finish.wait()
+            await updater.update_status(TaskState.TASK_STATE_COMPLETED)
+
+        async def cancel(
+            self, context: RequestContext, event_queue: EventQueue
+        ):
+            return None
+
+    agent = FinishingAgent()
+
+    handler = DefaultRequestHandler(
+        agent_executor=agent,
+        task_store=task_store,
+        queue_manager=queue_manager,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_persist',
+            parts=[Part(text='Test')],
+        )
+    )
+
+    # Start streaming and consume the first event (working)
+    agen = handler.on_message_send_stream(params, create_server_call_context())
+    first = await agen.__anext__()
+    if isinstance(first, TaskStatusUpdateEvent):
+        assert first.status.state == TaskState.TASK_STATE_WORKING
+        task_id = first.task_id
+    else:
+        assert (
+            isinstance(first, Task)
+            and first.status.state == TaskState.TASK_STATE_WORKING
+        )
+        task_id = first.id
+
+    # Disconnect client
+    await asyncio.wait_for(agen.aclose(), timeout=0.1)
+
+    # Finish agent and allow background consumer to persist final state
+    agent.allow_finish.set()
+
+    # Wait until background_consume task for this task_id is gone
+    await wait_until(
+        lambda: all(
+            not t.get_name().startswith(f'background_consume:{task_id}')
+            for t in handler._background_tasks
+        ),
+        timeout=1.0,
+        interval=0.01,
+    )
+
+    # Verify task is persisted as completed
+    persisted = await task_store.get(task_id, create_server_call_context())
+    assert persisted is not None
+    assert persisted.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+async def wait_until(predicate, timeout: float = 0.2, interval: float = 0.0):
+    """Await until predicate() is True or timeout elapses."""
+    loop = asyncio.get_running_loop()
+    end = loop.time() + timeout
+    while True:
+        if predicate():
+            return
+        if loop.time() >= end:
+            raise AssertionError('condition not met within timeout')
+        await asyncio.sleep(interval)
+
+
+@pytest.mark.asyncio
+async def test_background_cleanup_task_is_tracked_and_cleared(agent_card):
+    """Ensure background cleanup task is tracked while pending and removed when done."""
+    # Arrange
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    task_id = 'track_task_1'
+    context_id = 'track_ctx_1'
+
+    # Return an existing task from the store to avoid "task not found" error
+    existing_task = create_sample_task(task_id=task_id, context_id=context_id)
+    mock_task_store.get.return_value = existing_task
+
+    # RequestContext with IDs
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = task_id
+    mock_request_context.context_id = context_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    mock_queue = AsyncMock(spec=EventQueueLegacy)
+    mock_queue_manager.create_or_tap.return_value = mock_queue
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='mid_track',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+            context_id=context_id,
+        )
+    )
+
+    # Agent executor runs in background until we allow it to finish
+    execute_started = asyncio.Event()
+    execute_finish = asyncio.Event()
+
+    async def exec_side_effect(*_args, **_kwargs):
+        execute_started.set()
+        await execute_finish.wait()
+
+    mock_agent_executor.execute.side_effect = exec_side_effect
+
+    # ResultAggregator emits one Task event (so the stream yields once)
+    first_event = create_sample_task(task_id=task_id, context_id=context_id)
+
+    async def single_event_stream():
+        yield first_event
+
+    mock_result_aggregator_instance = MagicMock(spec=ResultAggregator)
+    mock_result_aggregator_instance.consume_and_emit.return_value = (
+        single_event_stream()
+    )
+
+    produced_task: asyncio.Task | None = None
+    cleanup_task: asyncio.Task | None = None
+
+    orig_create_task = asyncio.create_task
+
+    def create_task_spy(coro):
+        nonlocal produced_task, cleanup_task
+        task = orig_create_task(coro)
+        if coro.__name__ == '_run_event_stream':
+            produced_task = task
+        elif coro.__name__ == '_cleanup_producer':
+            cleanup_task = task
+        return task
+
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch('asyncio.create_task', side_effect=create_task_spy),
+    ):
+        # Act: start stream and consume only the first event, then disconnect
+        agen = request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        )
+        first = await agen.__anext__()
+        assert first == first_event
+        # Simulate client disconnect
+        await asyncio.wait_for(agen.aclose(), timeout=0.1)
+
+    assert produced_task is not None
+    assert cleanup_task is not None
+
+    # Background cleanup task should be tracked while producer is still running
+    await asyncio.wait_for(execute_started.wait(), timeout=0.1)
+    assert cleanup_task in request_handler._background_tasks
+
+    # Allow executor to finish; this should complete producer, then cleanup
+    execute_finish.set()
+    await asyncio.wait_for(produced_task, timeout=0.1)
+    await asyncio.wait_for(cleanup_task, timeout=0.1)
+
+    # Wait for callback to remove task from tracking
+    await wait_until(
+        lambda: cleanup_task not in request_handler._background_tasks,
+        timeout=0.1,
+    )
+
+    # Cleanup any lingering background tasks
+    for t in list(request_handler._background_tasks):
+        t.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await t
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_task_id_mismatch(agent_card):
+    """Test on_message_send_stream raises error if yielded task ID mismatches."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(
+        spec=AgentExecutor
+    )  # Only need a basic mock
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    context_task_id = 'stream_task_id_ctx'
+    mismatched_task_id = 'DIFFERENT_stream_task_id'
+
+    mock_request_context = MagicMock(spec=RequestContext)
+    mock_request_context.task_id = context_task_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_stream_mismatch',
+            parts=[Part(text='Test')],
+        )
+    )
+
+    mock_result_aggregator_instance = AsyncMock(spec=ResultAggregator)
+    mismatched_task_event = create_sample_task(
+        task_id=mismatched_task_id
+    )  # Task with different ID
+
+    async def event_stream_gen_mismatch():
+        yield mismatched_task_event
+
+    mock_result_aggregator_instance.consume_and_emit.return_value = (
+        event_stream_gen_mismatch()
+    )
+
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.ResultAggregator',
+            return_value=mock_result_aggregator_instance,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):
+        with pytest.raises(InternalError) as exc_info:
+            async for _ in request_handler.on_message_send_stream(
+                params, create_server_call_context()
+            ):
+                pass  # Consume the stream to trigger the error
+
+    assert 'Task ID mismatch' in exc_info.value.message  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_cleanup_producer_task_id_not_in_running_agents(agent_card):
+    """Test _cleanup_producer when task_id is not in _running_agents (e.g., already cleaned up)."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+
+    task_id = 'task_already_cleaned'
+
+    # Create a real, completed asyncio.Task for the test
+    async def noop_coro_for_task():
+        pass
+
+    mock_producer_task = asyncio.create_task(noop_coro_for_task())
+    await asyncio.sleep(
+        0
+    )  # Ensure the task has a chance to complete/be scheduled
+
+    # Call cleanup directly, ensuring task_id is NOT in _running_agents
+    # This simulates a race condition or double cleanup.
+    if task_id in request_handler._running_agents:
+        del request_handler._running_agents[task_id]  # Ensure it's not there
+
+    try:
+        await request_handler._cleanup_producer(mock_producer_task, task_id)
+    except Exception as e:
+        pytest.fail(f'_cleanup_producer raised an exception unexpectedly: {e}')
+
+    # Verify queue_manager.close was still called
+    mock_queue_manager.close.assert_awaited_once_with(task_id)
+    # No error should be raised by pop if key is missing and default is None.
+
+
+@pytest.mark.asyncio
+async def test_set_task_push_notification_config_no_notifier(agent_card):
+    """Test on_create_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,  # Explicitly None,
+        agent_card=agent_card,
+    )
+    params = TaskPushNotificationConfig(
+        task_id='task1',
+        url='http://example.com',
+    )
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_create_task_push_notification_config(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_set_task_push_notification_config_task_not_found(agent_card):
+    """Test on_create_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None  # Task not found
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_push_sender = AsyncMock(spec=PushNotificationSender)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        push_sender=mock_push_sender,
+        agent_card=agent_card,
+    )
+    params = TaskPushNotificationConfig(
+        task_id='non_existent_task',
+        url='http://example.com',
+    )
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_create_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.set_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('store_kind', ['inmemory', 'database'])
+async def test_create_task_push_notification_config_returns_stored_id(
+    agent_card, store_kind
+):
+    """Test on_create_task_push_notification_config returns the id that was stored."""
+    if store_kind == 'database':
+        pytest.importorskip('sqlalchemy')
+        pytest.importorskip('aiosqlite')
+        from a2a.server.tasks.database_push_notification_config_store import (
+            DatabasePushNotificationConfigStore,
+        )
+        from sqlalchemy.ext.asyncio import create_async_engine
+
+        engine = create_async_engine(
+            'sqlite+aiosqlite:///file:pushid?mode=memory&cache=shared&uri=true'
+        )
+        push_config_store = DatabasePushNotificationConfigStore(engine=engine)
+    else:
+        push_config_store = InMemoryPushNotificationConfigStore()
+
+    task = create_sample_task()
+    task_store = InMemoryTaskStore()
+    context = create_server_call_context()
+    await task_store.save(task, context)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_config_store,
+        agent_card=agent_card,
+    )
+    params = TaskPushNotificationConfig(
+        task_id=task.id,
+        url='http://example.com',
+    )
+
+    response = await request_handler.on_create_task_push_notification_config(
+        params, context
+    )
+
+    stored = await push_config_store.get_info(task.id, context)
+    if store_kind == 'database':
+        await engine.dispose()
+
+    assert response.id == task.id
+    assert list(stored) == [response]
+    assert params.id == '', 'the request object must not be mutated'
+
+
+@pytest.mark.asyncio
+async def test_create_task_push_notification_config_normalizes_when_store_returns_none(
+    agent_card,
+):
+    """A custom store that still returns None from set_info keeps working."""
+    push_config_store = AsyncMock(spec=PushNotificationConfigStore)
+    push_config_store.set_info.return_value = None
+
+    task = create_sample_task()
+    task_store = InMemoryTaskStore()
+    context = create_server_call_context()
+    await task_store.save(task, context)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_config_store,
+        agent_card=agent_card,
+    )
+    params = TaskPushNotificationConfig(
+        task_id=task.id, url='http://example.com'
+    )
+
+    response = await request_handler.on_create_task_push_notification_config(
+        params, context
+    )
+
+    assert (response.task_id, response.id) == (task.id, task.id)
+    assert params.id == '', 'the request object must not be mutated'
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_no_store(agent_card):
+    """Test on_get_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,  # Explicitly None,
+        agent_card=agent_card,
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='task1',
+        id='task_push_notification_config',
+    )
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_get_task_push_notification_config(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_task_not_found(agent_card):
+    """Test on_get_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None  # Task not found
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=agent_card,
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='task_push_notification_config'
+    )
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_not_found(agent_card):
+    """Test on_get_task_push_notification_config when push_config_store.get_info returns None."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_push_store.get_info.return_value = None  # Info not found
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=agent_card,
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='task_push_notification_config'
+    )
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_awaited_once_with(
+        'non_existent_task', context
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_with_config(agent_card):
+    """Test on_get_task_push_notification_config with valid push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', id='config_id', url='http://example.com'
+    )
+    context = create_server_call_context()
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params, context
+    )
+
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='task_1', id='config_id'
+    )
+
+    result: TaskPushNotificationConfig = (
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    )
+
+    assert result is not None
+    assert result.task_id == 'task_1'
+    assert result.url == set_config_params.url
+    assert result.id == 'config_id'
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_with_config_no_id(
+    agent_card,
+):
+    """Test on_get_task_push_notification_config with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1',
+        url='http://example.com',
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params, create_server_call_context()
+    )
+
+    params = GetTaskPushNotificationConfigRequest(task_id='task_1', id='task_1')
+
+    result: TaskPushNotificationConfig = (
+        await request_handler.on_get_task_push_notification_config(
+            params, create_server_call_context()
+        )
+    )
+
+    assert result is not None
+    assert result.task_id == 'task_1'
+    assert result.url == set_config_params.url
+    assert result.id == 'task_1'
+
+
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_task_not_found(agent_card):
+    """Test on_subscribe_to_task when the task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None  # Task not found
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = SubscribeToTaskRequest(id='resub_task_not_found')
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        # Need to consume the async generator to trigger the error
+        async for _ in request_handler.on_subscribe_to_task(params, context):
+            pass
+    mock_task_store.get.assert_awaited_once_with(
+        'resub_task_not_found', context
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_queue_not_found(agent_card):
+    """Test on_subscribe_to_task when the queue is not found by queue_manager.tap."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='resub_queue_not_found')
+    mock_task_store.get.return_value = sample_task
+
+    mock_queue_manager = AsyncMock(spec=QueueManager)
+    mock_queue_manager.tap.return_value = None  # Queue not found
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        queue_manager=mock_queue_manager,
+        agent_card=agent_card,
+    )
+    params = SubscribeToTaskRequest(id='resub_queue_not_found')
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        async for _ in request_handler.on_subscribe_to_task(params, context):
+            pass
+    mock_task_store.get.assert_awaited_once_with(
+        'resub_queue_not_found', context
+    )
+    mock_queue_manager.tap.assert_awaited_once_with('resub_queue_not_found')
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream(agent_card):
+    request_handler = DefaultRequestHandler(
+        MockAgentExecutor(),
+        InMemoryTaskStore(),
+        agent_card=agent_card,
+    )
+    message_params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-123',
+            parts=[Part(text='How are you?')],
+        ),
+    )
+
+    async def consume_stream():
+        events = []
+        async for event in request_handler.on_message_send_stream(
+            message_params, create_server_call_context()
+        ):
+            events.append(event)
+            if len(events) >= 3:
+                break  # Stop after a few events
+
+        return events
+
+    # Consume first 3 events from the stream and measure time
+    start = time.perf_counter()
+    events = await consume_stream()
+    elapsed = time.perf_counter() - start
+
+    # Assert we received events quickly
+    assert len(events) == 3
+    assert elapsed < 0.5
+
+    texts = [p.text for e in events for p in e.status.message.parts]
+    assert texts == ['Event 0', 'Event 1', 'Event 2']
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_no_store(agent_card):
+    """Test on_list_task_push_notification_configs when _push_config_store is None."""
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,  # Explicitly None,
+        agent_card=agent_card,
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='task1')
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_list_task_push_notification_configs(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_task_not_found(agent_card):
+    """Test on_list_task_push_notification_configs when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None  # Task not found
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=agent_card,
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='non_existent_task')
+
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_list_task_push_notification_configs(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_list_no_task_push_notification_config_info(agent_card):
+    """Test on_get_task_push_notification_config when push_config_store.get_info returns []"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='non_existent_task')
+
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+    assert result.configs == []
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_info_with_config(agent_card):
+    """Test on_list_task_push_notification_configs with push config+id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+
+    push_config1 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_1', url='http://example.com'
+    )
+    push_config2 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_2', url='http://example.com'
+    )
+
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config1, context)
+    await push_store.set_info('task_1', push_config2, context)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='task_1')
+
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+
+    assert len(result.configs) == 2
+    assert result.configs[0].task_id == 'task_1'
+    assert result.configs[0] == push_config1
+    assert result.configs[1].task_id == 'task_1'
+    assert result.configs[1] == push_config2
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_info_with_config_and_no_id(
+    agent_card,
+):
+    """Test on_list_task_push_notification_configs with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    # multiple calls without config id should replace the existing
+    set_config_params1 = TaskPushNotificationConfig(
+        task_id='task_1',
+        url='http://example.com',
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params1, create_server_call_context()
+    )
+
+    set_config_params2 = TaskPushNotificationConfig(
+        task_id='task_1',
+        url='http://example.com',
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params2, create_server_call_context()
+    )
+
+    params = ListTaskPushNotificationConfigsRequest(task_id='task_1')
+
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+
+    assert len(result.configs) == 1
+    assert result.configs[0].task_id == 'task_1'
+    assert result.configs[0].url == set_config_params2.url
+    assert result.configs[0].id == 'task_1'
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_no_store(agent_card):
+    """Test on_delete_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,  # Explicitly None,
+        agent_card=agent_card,
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task1', id='config1'
+    )
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_delete_task_push_notification_config(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_task_not_found(agent_card):
+    """Test on_delete_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None  # Task not found
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=agent_card,
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='config1'
+    )
+
+    context = create_server_call_context()
+
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_delete_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_delete_no_task_push_notification_config_info(agent_card):
+    """Test on_delete_task_push_notification_config without config info"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='task_1')
+    mock_task_store.get.return_value = sample_task
+
+    push_store = InMemoryPushNotificationConfigStore()
+    await push_store.set_info(
+        'task_2',
+        TaskPushNotificationConfig(id='config_1', url='http://example.com'),
+        create_server_call_context(),
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task1', id='config_non_existant'
+    )
+
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result is None
+
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task2', id='config_non_existant'
+    )
+
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_info_with_config(
+    agent_card,
+):
+    """Test on_list_task_push_notification_configs with push config+id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+
+    push_config1 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_1', url='http://example.com'
+    )
+    push_config2 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_2', url='http://example.com'
+    )
+
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config1, context)
+    await push_store.set_info('task_1', push_config2, context)
+    await push_store.set_info('task_2', push_config1, context)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task_1', id='config_1'
+    )
+
+    result1 = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+
+    assert result1 is None
+
+    result2 = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task_1'),
+        create_server_call_context(),
+    )
+
+    assert len(result2.configs) == 1
+    assert result2.configs[0].task_id == 'task_1'
+    assert result2.configs[0] == push_config2
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_info_with_config_and_no_id(
+    agent_card,
+):
+    """Test on_list_task_push_notification_configs with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+
+    push_config = TaskPushNotificationConfig(url='http://example.com')
+
+    # insertion without id should replace the existing config
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config, context)
+    await push_store.set_info('task_1', push_config, context)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task_1', id='task_1'
+    )
+
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+
+    assert result is None
+
+    result2 = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task_1'),
+        create_server_call_context(),
+    )
+
+    assert len(result2.configs) == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_message_send_task_in_terminal_state(
+    terminal_state, agent_card
+):
+    """Test on_message_send when task is already in a terminal state."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'terminal_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+
+    mock_task_store = AsyncMock(spec=TaskStore)
+    # The get method of TaskManager calls task_store.get.
+    # We mock TaskManager.get_task which is an async method.
+    # So we should patch that instead.
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_terminal',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+        )
+    )
+
+    # Patch the TaskManager's get_task method to return our terminal task
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+        return_value=terminal_task,
+    ):
+        with pytest.raises(UnsupportedOperationError) as exc_info:
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_message_send_stream_task_in_terminal_state(
+    terminal_state, agent_card
+):
+    """Test on_message_send_stream when task is already in a terminal state."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'terminal_stream_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_terminal_stream',
+            parts=[Part(text='Test')],
+            task_id=task_id,
+        )
+    )
+
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+        return_value=terminal_task,
+    ):
+        with pytest.raises(UnsupportedOperationError) as exc_info:
+            async for _ in request_handler.on_message_send_stream(
+                params, create_server_call_context()
+            ):
+                pass  # pragma: no cover
+
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_subscribe_to_task_in_terminal_state(
+    terminal_state, agent_card
+):
+    """Test on_subscribe_to_task when task is in a terminal state."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'resub_terminal_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = terminal_task
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        queue_manager=AsyncMock(spec=QueueManager),
+        agent_card=agent_card,
+    )
+    params = SubscribeToTaskRequest(id=f'{task_id}')
+
+    context = create_server_call_context()
+
+    with pytest.raises(UnsupportedOperationError) as exc_info:
+        async for _ in request_handler.on_subscribe_to_task(params, context):
+            pass  # pragma: no cover
+
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+    mock_task_store.get.assert_awaited_once_with(f'{task_id}', context)
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_task_id_provided_but_task_not_found(agent_card):
+    """Test on_message_send when task_id is provided but task doesn't exist."""
+    task_id = 'nonexistent_task'
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_nonexistent',
+            parts=[Part(text='Hello')],
+            task_id=task_id,
+            context_id='ctx1',
+        )
+    )
+
+    # Mock TaskManager.get_task to return None (task not found)
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+        return_value=None,
+    ):
+        with pytest.raises(TaskNotFoundError) as exc_info:
+            await request_handler.on_message_send(
+                params, create_server_call_context()
+            )
+
+    assert (
+        f'Task {task_id} was specified but does not exist'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_task_id_provided_but_task_not_found(
+    agent_card,
+):
+    """Test on_message_send_stream when task_id is provided but task doesn't exist."""
+    task_id = 'nonexistent_stream_task'
+    mock_task_store = AsyncMock(spec=TaskStore)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_nonexistent_stream',
+            parts=[Part(text='Hello')],
+            task_id=task_id,
+            context_id='ctx1',
+        )
+    )
+
+    # Mock TaskManager.get_task to return None (task not found)
+    with patch(
+        'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+        return_value=None,
+    ):
+        with pytest.raises(TaskNotFoundError) as exc_info:
+            # Need to consume the async generator to trigger the error
+            async for _ in request_handler.on_message_send_stream(
+                params, create_server_call_context()
+            ):
+                pass
+
+    assert (
+        f'Task {task_id} was specified but does not exist'
+        in exc_info.value.message
+    )
+
+
+class HelloWorldAgentExecutor(AgentExecutor):
+    """Test Agent Implementation."""
+
+    async def execute(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ) -> None:
+        updater = TaskUpdater(
+            event_queue,
+            task_id=context.task_id or str(uuid.uuid4()),
+            context_id=context.context_id or str(uuid.uuid4()),
+        )
+        await updater.update_status(TaskState.TASK_STATE_WORKING)
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        raise NotImplementedError('cancel not supported')
+
+
+# Repro is straight from the https://github.com/a2aproject/a2a-python/issues/609.
+# It uses timeout to test against infinite wait, if it's going to be flaky,
+# we should reconsider the approach.
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_error_does_not_hang(agent_card):
+    """Test that if the consumer raises an exception during blocking wait, the producer is cancelled and no deadlock occurs."""
+    agent = HelloWorldAgentExecutor()
+    task_store = AsyncMock(spec=TaskStore)
+    task_store.get.return_value = None
+    task_store.save.side_effect = RuntimeError('This is an Error!')
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=agent,
+        task_store=task_store,
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_error_blocking',
+            parts=[Part(text='Test message')],
+        )
+    )
+
+    with pytest.raises(RuntimeError, match='This is an Error!'):
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_negative_history_length_error(agent_card):
+    """Test on_get_task raises error for negative history length."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    # GetTaskRequest also has history_length
+    params = GetTaskRequest(id='task1', history_length=-1)
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_get_task(params, context)
+
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_page_size_too_small(agent_card):
+    """Test on_list_tasks raises error for page_size < 1."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(page_size=0)
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+
+    assert 'minimum page size is 1' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_page_size_too_large(agent_card):
+    """Test on_list_tasks raises error for page_size > 100."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+    params = ListTasksRequest(page_size=101)
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+
+    assert 'maximum page size is 100' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_negative_history_length_error(agent_card):
+    """Test on_message_send raises error for negative history length in configuration."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    message_config = SendMessageConfiguration(
+        history_length=-1,
+        accepted_output_modes=['text/plain'],
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='msg1', parts=[Part(text='Test')]
+        ),
+        configuration=message_config,
+    )
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_message_send(params, context)
+
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_negative_history_length_error(
+    agent_card,
+):
+    """Test on_message_send_stream raises error for negative history length in configuration."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    request_handler = DefaultRequestHandler(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        agent_card=agent_card,
+    )
+
+    message_config = SendMessageConfiguration(
+        history_length=-1,
+        accepted_output_modes=['text/plain'],
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='msg1', parts=[Part(text='Test')]
+        ),
+        configuration=message_config,
+    )
+    context = create_server_call_context()
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        async for _ in request_handler.on_message_send_stream(params, context):
+            pass
+
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_get_extended_agent_card_success(agent_card):
+    """Test on_get_extended_agent_card when extended_agent_card is supported."""
+    agent_card.capabilities.extended_agent_card = True
+
+    extended_agent_card = AgentCard(
+        name='Extended Agent',
+        description='An extended agent',
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=True,
+            push_notifications=True,
+            extended_agent_card=True,
+        ),
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        agent_card=agent_card,
+        extended_agent_card=extended_agent_card,
+    )
+
+    params = GetExtendedAgentCardRequest()
+    context = create_server_call_context()
+
+    result = await request_handler.on_get_extended_agent_card(params, context)
+
+    assert result == extended_agent_card
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_unsupported(agent_card):
+    """Test on_message_send_stream when streaming is unsupported."""
+    agent_card.capabilities.streaming = False
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        agent_card=agent_card,
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-unsupported',
+            parts=[Part(text='hi')],
+        )
+    )
+
+    context = create_server_call_context()
+
+    with pytest.raises(UnsupportedOperationError):
+        async for _ in request_handler.on_message_send_stream(params, context):
+            pass
+
+
+@pytest.mark.asyncio
+async def test_on_get_extended_agent_card_unsupported(agent_card):
+    """Test on_get_extended_agent_card when extended_agent_card is unsupported."""
+    agent_card.capabilities.extended_agent_card = False
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        agent_card=agent_card,
+    )
+
+    params = GetExtendedAgentCardRequest()
+    context = create_server_call_context()
+
+    with pytest.raises(UnsupportedOperationError):
+        await request_handler.on_get_extended_agent_card(params, context)
+
+
+@pytest.mark.asyncio
+async def test_on_create_task_push_notification_config_unsupported(agent_card):
+    """Test on_create_task_push_notification_config when push_notifications is unsupported."""
+    agent_card.capabilities.push_notifications = False
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        agent_card=agent_card,
+    )
+
+    params = TaskPushNotificationConfig(url='http://example.com/push')
+
+    context = create_server_call_context()
+
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_create_task_push_notification_config(
+            params, context
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_unsupported(agent_card):
+    """Test on_subscribe_to_task when streaming is unsupported."""
+    agent_card.capabilities.streaming = False
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        agent_card=agent_card,
+    )
+
+    params = SubscribeToTaskRequest(id='some_task')
+    context = create_server_call_context()
+
+    with pytest.raises(UnsupportedOperationError):
+        # We need to exhaust the generator to trigger the decorator evaluation
+        async for _ in request_handler.on_subscribe_to_task(params, context):
+            pass
+
+
+class _NamedUser(User):
+    """Minimal authenticated test user identified by ``user_name``."""
+
+    def __init__(self, user_name: str) -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def _ctx(user_name: str) -> ServerCallContext:
+    return ServerCallContext(user=_NamedUser(user_name))
+
+
+@pytest.mark.asyncio
+async def test_on_list_task_push_notification_configs_is_owner_scoped(
+    agent_card,
+):
+    """Bob must not see Alice's configs via tasks/pushNotificationConfig/list.
+
+    Both users have access to the shared task (the mocked TaskStore
+    returns it for any caller), but listing must only return the
+    caller's own configs.
+    """
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = create_sample_task(task_id='shared-task')
+
+    push_store = InMemoryPushNotificationConfigStore()
+    alice_ctx = _ctx('alice')
+    bob_ctx = _ctx('bob')
+
+    alice_cfg = TaskPushNotificationConfig(
+        task_id='shared-task',
+        id='alice-cfg',
+        url='http://alice.example.com/cb',
+        token='alice-secret',
+    )
+    bob_cfg = TaskPushNotificationConfig(
+        task_id='shared-task',
+        id='bob-cfg',
+        url='http://bob.example.com/cb',
+        token='bob-secret',
+    )
+    await push_store.set_info('shared-task', alice_cfg, alice_ctx)
+    await push_store.set_info('shared-task', bob_cfg, bob_ctx)
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    alice_listing = (
+        await request_handler.on_list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id='shared-task'),
+            alice_ctx,
+        )
+    )
+    assert {c.id for c in alice_listing.configs} == {'alice-cfg'}
+    # Sanity: Bob's secret is not in the response.
+    assert all(c.token != 'bob-secret' for c in alice_listing.configs), (
+        'Listing for Alice must not expose Bob-owned tokens'
+    )
+
+    bob_listing = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='shared-task'),
+        bob_ctx,
+    )
+    assert {c.id for c in bob_listing.configs} == {'bob-cfg'}
+    assert all(c.token != 'alice-secret' for c in bob_listing.configs), (
+        'Listing for Bob must not expose Alice-owned tokens'
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_list_task_push_notification_configs_returns_empty_for_third_user(
+    agent_card,
+):
+    """A third user with task access but no registered configs sees an empty list."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = create_sample_task(task_id='shared-task')
+
+    push_store = InMemoryPushNotificationConfigStore()
+    await push_store.set_info(
+        'shared-task',
+        TaskPushNotificationConfig(
+            task_id='shared-task',
+            id='alice-cfg',
+            url='http://alice.example.com/cb',
+        ),
+        _ctx('alice'),
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    carol_listing = (
+        await request_handler.on_list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id='shared-task'),
+            _ctx('carol'),
+        )
+    )
+    assert carol_listing.configs == []
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_push_notification_config_is_owner_scoped(
+    agent_card,
+):
+    """Bob cannot fetch Alice's config by ID via tasks/pushNotificationConfig/get.
+
+    Even when Bob can read the task and knows (or guesses) the
+    config_id, the handler must raise TaskNotFoundError because Alice's
+    config is not in Bob's owner partition.
+    """
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = create_sample_task(task_id='shared-task')
+
+    push_store = InMemoryPushNotificationConfigStore()
+    alice_ctx = _ctx('alice')
+    await push_store.set_info(
+        'shared-task',
+        TaskPushNotificationConfig(
+            task_id='shared-task',
+            id='alice-cfg',
+            url='http://alice.example.com/cb',
+            token='alice-secret',
+        ),
+        alice_ctx,
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+
+    # Alice can read her own config.
+    alice_view = await request_handler.on_get_task_push_notification_config(
+        GetTaskPushNotificationConfigRequest(
+            task_id='shared-task', id='alice-cfg'
+        ),
+        alice_ctx,
+    )
+    assert alice_view.id == 'alice-cfg'
+    assert alice_view.token == 'alice-secret'
+
+    # Bob cannot, even guessing the exact config_id.
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            GetTaskPushNotificationConfigRequest(
+                task_id='shared-task', id='alice-cfg'
+            ),
+            _ctx('bob'),
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_create_task_push_notification_config_rejects_invalid_url(
+    agent_card,
+):
+    """Test on_create_task_push_notification_config rejects non-public URLs."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+        push_url_validator=validate_push_notification_url,
+    )
+    context = create_server_call_context()
+
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', id='config_id', url='http://127.0.0.1/hook'
+    )
+    with pytest.raises(
+        InvalidParamsError, match='Invalid push notification URL'
+    ):
+        await request_handler.on_create_task_push_notification_config(
+            set_config_params, context
+        )
+
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', id='config_id', url='file:///etc/passwd'
+    )
+    with pytest.raises(
+        InvalidParamsError, match='Invalid push notification URL'
+    ):
+        await request_handler.on_create_task_push_notification_config(
+            set_config_params, context
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_create_task_push_notification_config_skips_when_validator_none(
+    agent_card,
+):
+    """Default push_url_validator is None, so library screening is off."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+    )
+    context = create_server_call_context()
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', id='config_id', url='http://127.0.0.1/hook'
+    )
+    result = await request_handler.on_create_task_push_notification_config(
+        set_config_params, context
+    )
+    assert result.url == 'http://127.0.0.1/hook'
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_rejects_invalid_push_url(agent_card):
+    """Inline push config on message send is screened before set_info."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandler(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=agent_card,
+        push_url_validator=validate_push_notification_url,
+    )
+    context = create_server_call_context()
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_bad_push',
+            parts=[Part(text='Test')],
+        ),
+        configuration=SendMessageConfiguration(
+            task_push_notification_config=TaskPushNotificationConfig(
+                url='http://127.0.0.1/hook'
+            ),
+            accepted_output_modes=['text/plain'],
+        ),
+    )
+    with pytest.raises(
+        InvalidParamsError, match='Invalid push notification URL'
+    ):
+        await request_handler.on_message_send(params, context)
+
+
+def _complete_agent_card() -> AgentCard:
+    """Returns an AgentCard with every field the A2A spec marks REQUIRED."""
+    return AgentCard(
+        name='complete_agent',
+        description='An agent card with all required fields.',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://localhost:8000',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            )
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            AgentSkill(
+                id='echo',
+                name='Echo',
+                description='Echoes the input.',
+                tags=['test'],
+            )
+        ],
+    )
+
+
+def test_init_warns_about_incomplete_agent_cards(
+    agent_card: AgentCard,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Cards missing REQUIRED fields are accepted, but each one is logged."""
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        DefaultRequestHandler(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=agent_card,
+            extended_agent_card=AgentCard(),
+        )
+    messages = [record.getMessage() for record in caplog.records]
+    assert len(messages) == 2
+    assert messages[0].startswith('agent_card passed to DefaultRequestHandler:')
+    assert messages[1].startswith(
+        'extended_agent_card passed to DefaultRequestHandler:'
+    )
+
+
+def test_init_does_not_warn_for_complete_agent_cards(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        DefaultRequestHandler(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=_complete_agent_card(),
+            extended_agent_card=_complete_agent_card(),
+        )
+    assert caplog.records == []
+
+
+@pytest.mark.asyncio
+async def test_push_sender_failure_does_not_propagate(agent_card):
+    """A push-notification infrastructure failure raised by the sender must
+    not propagate out of _send_push_notification_if_needed into the task
+    lifecycle (#1313)."""
+    mock_push_sender = AsyncMock(spec=PushNotificationSender)
+    mock_push_sender.send_notification.side_effect = RuntimeError(
+        'transient push infrastructure error'
+    )
+    request_handler = DefaultRequestHandler(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=AsyncMock(spec=PushNotificationConfigStore),
+        push_sender=mock_push_sender,
+        agent_card=agent_card,
+    )
+    event = create_sample_task()
+
+    # Must not raise: push delivery is best-effort.
+    await request_handler._send_push_notification_if_needed(event.id, event)
+
+    mock_push_sender.send_notification.assert_awaited_once_with(event.id, event)
+
+
+class _ContextRecordingAgent(AgentExecutor):
+    """Records the context id each execution is handed."""
+
+    def __init__(self) -> None:
+        self.seen_context_ids: list[str | None] = []
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        self.seen_context_ids.append(context.context_id)
+        updater = TaskUpdater(
+            event_queue,
+            context.task_id,  # type: ignore[arg-type]
+            context.context_id,  # type: ignore[arg-type]
+        )
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.mark.asyncio
+async def test_task_only_message_infers_context_id_from_task(agent_card):
+    """A2A 3.4.3: a message naming only a taskId inherits the task's context."""
+    agent = _ContextRecordingAgent()
+    task_store = InMemoryTaskStore()
+    call_context = create_server_call_context()
+    task = create_sample_task(
+        task_id='task-awaiting-input',
+        status_state=TaskState.TASK_STATE_INPUT_REQUIRED,
+        context_id='ctx-from-stored-task',
+    )
+    await task_store.save(task, call_context)
+    handler = DefaultRequestHandler(
+        agent_executor=agent,
+        task_store=task_store,
+        agent_card=agent_card,
+    )
+    params = SendMessageRequest(
+        message=Message(
+            message_id='msg-follow-up',
+            role=Role.ROLE_USER,
+            parts=[Part(text='Friday')],
+            task_id=task.id,
+        )
+    )
+
+    result = await handler.on_message_send(params, call_context)
+
+    assert agent.seen_context_ids == [task.context_id]
+    assert result.context_id == task.context_id
+    assert params.message.context_id == task.context_id
diff --git a/tests/server/request_handlers/test_default_request_handler_v2.py b/tests/server/request_handlers/test_default_request_handler_v2.py
new file mode 100644
index 000000000..ac87023b9
--- /dev/null
+++ b/tests/server/request_handlers/test_default_request_handler_v2.py
@@ -0,0 +1,3691 @@
+import asyncio
+import contextvars
+import logging
+import time
+import uuid
+import warnings
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from a2a.auth.user import UnauthenticatedUser, User
+from a2a.helpers.proto_helpers import (
+    new_task_from_user_message,
+    new_text_message,
+)
+from a2a.server.agent_execution import (
+    AgentExecutor,
+    RequestContext,
+    RequestContextBuilder,
+    SimpleRequestContextBuilder,
+)
+from a2a.server.agent_execution.active_task_registry import ActiveTaskRegistry
+from a2a.server.context import ServerCallContext
+from a2a.server.events import Event, EventQueue, InMemoryQueueManager
+from a2a.server.events.event_queue_v2 import EventQueueSource
+from a2a.server.request_handlers import DefaultRequestHandlerV2
+from a2a.server.tasks import (
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+    PushNotificationConfigStore,
+    PushNotificationSender,
+    TaskStore,
+    TaskUpdater,
+)
+from a2a.server.tasks.base_push_notification_sender import (
+    BasePushNotificationSender,
+)
+from a2a.server.tasks.task_manager import TaskManager
+from a2a.types import (
+    ContentTypeNotSupportedError,
+    InternalError,
+    InvalidAgentResponseError,
+    InvalidParamsError,
+    PushNotificationNotSupportedError,
+    TaskNotFoundError,
+    UnsupportedOperationError,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Artifact,
+    CancelTaskRequest,
+    DeleteTaskPushNotificationConfigRequest,
+    GetTaskPushNotificationConfigRequest,
+    GetTaskRequest,
+    ListTaskPushNotificationConfigsRequest,
+    ListTasksRequest,
+    ListTasksResponse,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.constants import TERMINAL_TASK_STATES
+
+
+def create_default_agent_card():
+    """Provides a standard AgentCard with streaming and push notifications enabled for tests."""
+    return AgentCard(
+        name='test_agent',
+        version='1.0',
+        capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+    )
+
+
+class MockAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        if context.message:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+
+        task_updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+
+        async for i in self._run():
+            parts = [Part(text=f'Event {i}')]
+            try:
+                await task_updater.update_status(
+                    TaskState.TASK_STATE_WORKING,
+                    message=task_updater.new_agent_message(parts),
+                )
+            except RuntimeError:
+                break
+
+    async def _run(self):
+        for i in range(1000000):
+            yield i
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+def create_sample_task(
+    task_id='task1',
+    status_state=TaskState.TASK_STATE_SUBMITTED,
+    context_id='ctx1',
+) -> Task:
+    return Task(
+        id=task_id, context_id=context_id, status=TaskStatus(state=status_state)
+    )
+
+
+def create_server_call_context() -> ServerCallContext:
+    return ServerCallContext(user=UnauthenticatedUser())
+
+
+class _StatusValidationRecoveryAgent(AgentExecutor):
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        assert context.message is not None
+        await event_queue.enqueue_event(
+            new_task_from_user_message(context.message)
+        )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        try:
+            await updater.update_status(
+                TaskState.TASK_STATE_COMPLETED,
+                timestamp='not-a-timestamp',
+            )
+        except ValueError:
+            await updater.failed()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.mark.asyncio
+async def test_status_validation_failure_returns_failed_task() -> None:
+    store = InMemoryTaskStore()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=_StatusValidationRecoveryAgent(),
+        task_store=store,
+        agent_card=create_default_agent_card(),
+    )
+    context = create_server_call_context()
+    try:
+        result = await asyncio.wait_for(
+            handler.on_message_send(
+                SendMessageRequest(
+                    message=Message(
+                        role=Role.ROLE_USER,
+                        message_id='validation-recovery',
+                        parts=[Part(text='test status recovery')],
+                    )
+                ),
+                context,
+            ),
+            timeout=5,
+        )
+        assert isinstance(result, Task)
+        assert result.status.state == TaskState.TASK_STATE_FAILED
+        stored = await store.get(result.id, context)
+        assert stored is not None
+        assert stored.status.state == TaskState.TASK_STATE_FAILED
+    finally:
+        await handler.aclose()
+
+
+class _CompletingAgent(AgentExecutor):
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        assert context.message is not None
+        await event_queue.enqueue_event(
+            new_task_from_user_message(context.message)
+        )
+        updater = TaskUpdater(
+            event_queue,
+            str(context.task_id or ''),
+            str(context.context_id or ''),
+        )
+        await updater.start_work()
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+class _FailCompletedSaveTaskStore(InMemoryTaskStore):
+    """Rejects the first COMPLETED write, as a lost database connection would."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.failed_save = False
+
+    async def save(self, task: Task, context: ServerCallContext) -> None:
+        if (
+            task.status.state == TaskState.TASK_STATE_COMPLETED
+            and not self.failed_save
+        ):
+            self.failed_save = True
+            raise ConnectionError('database connection lost')
+        await super().save(task, context)
+
+
+@pytest.mark.asyncio
+async def test_failed_terminal_save_records_failed_task() -> None:
+    store = _FailCompletedSaveTaskStore()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=_CompletingAgent(),
+        task_store=store,
+        agent_card=create_default_agent_card(),
+    )
+    context = create_server_call_context()
+    try:
+        with pytest.raises(ConnectionError, match='database connection lost'):
+            await asyncio.wait_for(
+                handler.on_message_send(
+                    SendMessageRequest(
+                        message=Message(
+                            role=Role.ROLE_USER,
+                            message_id='failed-terminal-save',
+                            parts=[Part(text='test failed save')],
+                        )
+                    ),
+                    context,
+                ),
+                timeout=5,
+            )
+        assert store.failed_save
+        listed = await store.list(ListTasksRequest(), context)
+        assert len(listed.tasks) == 1
+        # The COMPLETED write never landed, so the task must not stay WORKING.
+        assert listed.tasks[0].status.state == TaskState.TASK_STATE_FAILED
+    finally:
+        await handler.aclose()
+
+
+def test_init_default_dependencies():
+    """Test that default dependencies are created if not provided."""
+    agent_executor = MockAgentExecutor()
+    task_store = InMemoryTaskStore()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    assert isinstance(handler._active_task_registry, ActiveTaskRegistry)
+    assert isinstance(
+        handler._request_context_builder, SimpleRequestContextBuilder
+    )
+    assert handler._push_config_store is None
+    assert handler._push_sender is None
+    assert (
+        handler._request_context_builder._should_populate_referred_tasks
+        is False
+    )
+    assert handler._request_context_builder._task_store is None
+
+
+def test_init_warns_when_queue_manager_passed(caplog):
+    """A caller-supplied queue_manager is not honored in v2, so passing one
+    must emit a warning instead of being silently ignored (issue #1135).
+
+    Both channels are checked: the DeprecationWarning points at the caller's
+    construction site and is filterable in test suites, while the log line
+    still reaches headless servers, where DeprecationWarning is hidden by
+    Python's default filters outside __main__.
+    """
+    queue_manager = InMemoryQueueManager()
+    with (
+        caplog.at_level(logging.WARNING),
+        pytest.warns(DeprecationWarning, match='queue_manager') as record,
+    ):
+        DefaultRequestHandlerV2(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=create_default_agent_card(),
+            queue_manager=queue_manager,
+        )
+    # stacklevel=2 must attribute the warning to this file, not to the handler.
+    assert record[0].filename == __file__
+    assert any(
+        'queue_manager' in rec.message and rec.levelno == logging.WARNING
+        for rec in caplog.records
+    )
+
+
+def test_init_no_warning_without_queue_manager(caplog):
+    """No warning is emitted when queue_manager is omitted."""
+    with caplog.at_level(logging.WARNING), warnings.catch_warnings():
+        warnings.simplefilter('error', DeprecationWarning)
+        DefaultRequestHandlerV2(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=create_default_agent_card(),
+        )
+    assert not any(
+        'queue_manager' in record.message for record in caplog.records
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_not_found():
+    """Test on_get_task when task_store.get returns None."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = GetTaskRequest(id='non_existent_task')
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task(params, context)
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_success():
+    """Test on_list_tasks successfully returns a page of tasks ."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    task2 = create_sample_task(task_id='task2')
+    task2.artifacts.extend(
+        [
+            Artifact(
+                artifact_id='artifact1',
+                parts=[Part(text='Hello world!')],
+                name='conversion_result',
+            )
+        ]
+    )
+    mock_page = ListTasksResponse(
+        tasks=[create_sample_task(task_id='task1'), task2],
+        next_page_token='123',  # noqa: S106
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(include_artifacts=True, page_size=10)
+    context = create_server_call_context()
+    result = await request_handler.on_list_tasks(params, context)
+    mock_task_store.list.assert_awaited_once_with(params, context)
+    assert result.tasks == mock_page.tasks
+    assert result.next_page_token == mock_page.next_page_token
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_excludes_artifacts():
+    """Test on_list_tasks excludes artifacts from returned tasks."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    task2 = create_sample_task(task_id='task2')
+    task2.artifacts.extend(
+        [
+            Artifact(
+                artifact_id='artifact1',
+                parts=[Part(text='Hello world!')],
+                name='conversion_result',
+            )
+        ]
+    )
+    mock_page = ListTasksResponse(
+        tasks=[create_sample_task(task_id='task1'), task2],
+        next_page_token='123',  # noqa: S106
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(include_artifacts=False, page_size=10)
+    context = create_server_call_context()
+    result = await request_handler.on_list_tasks(params, context)
+    assert not result.tasks[1].artifacts
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_applies_history_length():
+    """Test on_list_tasks applies history length filter."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    history = [
+        new_text_message('Hello 1!'),
+        new_text_message('Hello 2!'),
+    ]
+    task2 = create_sample_task(task_id='task2')
+    task2.history.extend(history)
+    mock_page = ListTasksResponse(
+        tasks=[create_sample_task(task_id='task1'), task2],
+        next_page_token='123',  # noqa: S106
+    )
+    mock_task_store.list.return_value = mock_page
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(history_length=1, page_size=10)
+    context = create_server_call_context()
+    result = await request_handler.on_list_tasks(params, context)
+    assert result.tasks[1].history == [history[1]]
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_negative_history_length_error():
+    """Test on_list_tasks raises error for negative history length."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(history_length=-1, page_size=10)
+    context = create_server_call_context()
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_cancel_task_task_not_found():
+    """Test on_cancel_task when the task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = CancelTaskRequest(id='task_not_found_for_cancel')
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_cancel_task(params, context)
+    mock_task_store.get.assert_awaited_once_with(
+        'task_not_found_for_cancel', context
+    )
+
+
+class HelloAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = context.current_task
+        if not task:
+            assert context.message is not None, (
+                'A message is required to create a new task'
+            )
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        try:
+            parts = [Part(text='I am working')]
+            await updater.update_status(
+                TaskState.TASK_STATE_WORKING,
+                message=updater.new_agent_message(parts),
+            )
+        except Exception as e:  # noqa: BLE001
+            logging.warning('Error: %s', e)
+            return
+        await updater.add_artifact(
+            [Part(text='Hello world!')], name='conversion_result'
+        )
+        await updater.complete()
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class EarlyFailingAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        raise RuntimeError('early producer failure')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class LateFailingTerminalAgentExecutor(AgentExecutor):
+    def __init__(
+        self, terminal_state: TaskState, terminal_state_persisted: asyncio.Event
+    ) -> None:
+        self.terminal_state = terminal_state
+        self.terminal_state_persisted = terminal_state_persisted
+        self.raised = asyncio.Event()
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        assert context.message is not None
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        task_updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await task_updater.update_status(self.terminal_state)
+        await self.terminal_state_persisted.wait()
+        self.raised.set()
+        raise RuntimeError('late producer failure')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class FailsAfterTaskAgentExecutor(AgentExecutor):
+    """Enqueues a Task with its own metadata, then raises when allowed to."""
+
+    def __init__(self) -> None:
+        self.may_raise = asyncio.Event()
+        self.task_id: str | None = None
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        assert context.message is not None
+        task = new_task_from_user_message(context.message)
+        task.metadata.update({'agent_key': 'kept'})
+        self.task_id = task.id
+        await event_queue.enqueue_event(task)
+        # Bounded, so the test fails rather than hangs if the hook never fires.
+        await asyncio.wait_for(self.may_raise.wait(), timeout=5)
+        raise RuntimeError('model call failed')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class WorksThenFailsAgentExecutor(AgentExecutor):
+    """Reports WORKING with a status message, then raises."""
+
+    def __init__(self) -> None:
+        self.task_id: str | None = None
+        self.raised_at: datetime | None = None
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        assert context.message is not None
+        task = new_task_from_user_message(context.message)
+        self.task_id = task.id
+        await event_queue.enqueue_event(task)
+        task_updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await task_updater.update_status(
+            TaskState.TASK_STATE_WORKING,
+            message=task_updater.new_agent_message([Part(text='halfway')]),
+        )
+        # Fail only after the WORKING status, with its timestamp, is stored.
+        await asyncio.sleep(0.05)
+        self.raised_at = datetime.now(timezone.utc)
+        raise RuntimeError('model call failed')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class RepliesThenFailsAgentExecutor(AgentExecutor):
+    """Answers a follow-up with a Message, then raises."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task_updater = TaskUpdater(
+            event_queue, context.task_id, context.context_id
+        )
+        await event_queue.enqueue_event(
+            task_updater.new_agent_message([Part(text='on it')])
+        )
+        raise RuntimeError('model call failed')
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class FailedStatusAgentExecutor(AgentExecutor):
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        assert context.message is not None
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        task_updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await task_updater.update_status(TaskState.TASK_STATE_FAILED)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+class FailedStatusThenRaisesAgentExecutor(FailedStatusAgentExecutor):
+    def __init__(self) -> None:
+        self.exception = RuntimeError('late producer failure')
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        await super().execute(context, event_queue)
+        raise self.exception
+
+
+async def send_message_with_early_failure(
+    request_handler: DefaultRequestHandlerV2,
+    params: SendMessageRequest,
+    context: ServerCallContext,
+) -> Message | Task | None:
+    try:
+        return await request_handler.on_message_send(params, context)
+    except RuntimeError as e:
+        assert str(e) == 'early producer failure'
+        return None
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_limit_history():
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='msg_push', parts=[Part(text='Hi')]
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+    result = await request_handler.on_message_send(
+        params, create_server_call_context()
+    )
+    assert result is not None
+    assert isinstance(result, Task)
+    get_task_result = await request_handler.on_get_task(
+        GetTaskRequest(id=result.id, history_length=1),
+        create_server_call_context(),
+    )
+    assert get_task_result is not None
+    assert isinstance(get_task_result, Task)
+    assert (
+        get_task_result.history is not None
+        and len(get_task_result.history) == 1
+    )
+
+
+async def wait_until(predicate, timeout: float = 0.2, interval: float = 0.0):
+    """Await until predicate() is True or timeout elapses."""
+    loop = asyncio.get_running_loop()
+    end = loop.time() + timeout
+    while True:
+        if predicate():
+            return
+        if loop.time() >= end:
+            raise AssertionError('condition not met within timeout')
+        await asyncio.sleep(interval)
+
+
+@pytest.mark.asyncio
+async def test_set_task_push_notification_config_no_notifier():
+    """Test on_create_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,
+        agent_card=create_default_agent_card(),
+    )
+    params = TaskPushNotificationConfig(
+        task_id='task1', url='http://example.com'
+    )
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_create_task_push_notification_config(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_set_task_push_notification_config_task_not_found():
+    """Test on_create_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_push_sender = AsyncMock(spec=PushNotificationSender)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        push_sender=mock_push_sender,
+        agent_card=create_default_agent_card(),
+    )
+    params = TaskPushNotificationConfig(
+        task_id='non_existent_task', url='http://example.com'
+    )
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_create_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.set_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('store_kind', ['inmemory', 'database'])
+async def test_create_task_push_notification_config_returns_stored_id(
+    store_kind,
+):
+    """Test on_create_task_push_notification_config returns the id that was stored."""
+    if store_kind == 'database':
+        pytest.importorskip('sqlalchemy')
+        pytest.importorskip('aiosqlite')
+        from a2a.server.tasks.database_push_notification_config_store import (
+            DatabasePushNotificationConfigStore,
+        )
+        from sqlalchemy.ext.asyncio import create_async_engine
+
+        engine = create_async_engine(
+            'sqlite+aiosqlite:///file:pushidv2?mode=memory&cache=shared&uri=true'
+        )
+        push_config_store = DatabasePushNotificationConfigStore(engine=engine)
+    else:
+        push_config_store = InMemoryPushNotificationConfigStore()
+
+    task = create_sample_task()
+    task_store = InMemoryTaskStore()
+    context = create_server_call_context()
+    await task_store.save(task, context)
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_config_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = TaskPushNotificationConfig(
+        task_id=task.id, url='http://example.com'
+    )
+
+    response = await request_handler.on_create_task_push_notification_config(
+        params, context
+    )
+
+    stored = await push_config_store.get_info(task.id, context)
+    if store_kind == 'database':
+        await engine.dispose()
+
+    assert response.id == task.id
+    assert list(stored) == [response]
+    assert params.id == '', 'the request object must not be mutated'
+
+
+@pytest.mark.asyncio
+async def test_create_task_push_notification_config_normalizes_when_store_returns_none():
+    """A custom store that still returns None from set_info keeps working."""
+    push_config_store = AsyncMock(spec=PushNotificationConfigStore)
+    push_config_store.set_info.return_value = None
+
+    task = create_sample_task()
+    task_store = InMemoryTaskStore()
+    context = create_server_call_context()
+    await task_store.save(task, context)
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_config_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = TaskPushNotificationConfig(
+        task_id=task.id, url='http://example.com'
+    )
+
+    response = await request_handler.on_create_task_push_notification_config(
+        params, context
+    )
+
+    assert (response.task_id, response.id) == (task.id, task.id)
+    assert params.id == '', 'the request object must not be mutated'
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_no_store():
+    """Test on_get_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,
+        agent_card=create_default_agent_card(),
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='task1', id='task_push_notification_config'
+    )
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_get_task_push_notification_config(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_task_not_found():
+    """Test on_get_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='task_push_notification_config'
+    )
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_not_found():
+    """Test on_get_task_push_notification_config when push_config_store.get_info returns None."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    mock_push_store.get_info.return_value = None
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='task_push_notification_config'
+    )
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_awaited_once_with(
+        'non_existent_task', context
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_with_config():
+    """Test on_get_task_push_notification_config with valid push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', id='config_id', url='http://example.com'
+    )
+    context = create_server_call_context()
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params, context
+    )
+    params = GetTaskPushNotificationConfigRequest(
+        task_id='task_1', id='config_id'
+    )
+    result: TaskPushNotificationConfig = (
+        await request_handler.on_get_task_push_notification_config(
+            params, context
+        )
+    )
+    assert result is not None
+    assert result.task_id == 'task_1'
+    assert result.url == set_config_params.url
+    assert result.id == 'config_id'
+
+
+@pytest.mark.asyncio
+async def test_get_task_push_notification_config_info_with_config_no_id():
+    """Test on_get_task_push_notification_config with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    set_config_params = TaskPushNotificationConfig(
+        task_id='task_1', url='http://example.com'
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params, create_server_call_context()
+    )
+    params = GetTaskPushNotificationConfigRequest(task_id='task_1', id='task_1')
+    result: TaskPushNotificationConfig = (
+        await request_handler.on_get_task_push_notification_config(
+            params, create_server_call_context()
+        )
+    )
+    assert result is not None
+    assert result.task_id == 'task_1'
+    assert result.url == set_config_params.url
+    assert result.id == 'task_1'
+
+
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_task_not_found():
+    """Test on_subscribe_to_task when the task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SubscribeToTaskRequest(id='resub_task_not_found')
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        async for _ in request_handler.on_subscribe_to_task(params, context):
+            pass
+    mock_task_store.get.assert_awaited_once_with(
+        'resub_task_not_found', context
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream():
+    request_handler = DefaultRequestHandlerV2(
+        MockAgentExecutor(),
+        InMemoryTaskStore(),
+        create_default_agent_card(),
+    )
+    message_params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-123',
+            parts=[Part(text='How are you?')],
+        )
+    )
+
+    async def consume_stream():
+        events = []
+        async for event in request_handler.on_message_send_stream(
+            message_params, create_server_call_context()
+        ):
+            events.append(event)
+            if len(events) >= 3:
+                break
+        return events
+
+    start = time.perf_counter()
+    events = await consume_stream()
+    elapsed = time.perf_counter() - start
+    assert len(events) == 3
+    assert elapsed < 0.5
+    task, event0, event1 = events
+    assert isinstance(task, Task)
+    assert task.history[0].parts[0].text == 'How are you?'
+
+    assert isinstance(event0, TaskStatusUpdateEvent)
+    assert event0.status.message.parts[0].text == 'Event 0'
+
+    assert isinstance(event1, TaskStatusUpdateEvent)
+    assert event1.status.message.parts[0].text == 'Event 1'
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_no_store():
+    """Test on_list_task_push_notification_configs when _push_config_store is None."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='task1')
+    with pytest.raises(PushNotificationNotSupportedError):
+        await request_handler.on_list_task_push_notification_configs(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_task_not_found():
+    """Test on_list_task_push_notification_configs when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='non_existent_task')
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_list_task_push_notification_configs(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_list_no_task_push_notification_config_info():
+    """Test on_get_task_push_notification_config when push_config_store.get_info returns []"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='non_existent_task')
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+    assert result.configs == []
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_info_with_config():
+    """Test on_list_task_push_notification_configs with push config+id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+    push_config1 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_1', url='http://example.com'
+    )
+    push_config2 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_2', url='http://example.com'
+    )
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config1, context)
+    await push_store.set_info('task_1', push_config2, context)
+    await push_store.set_info('task_2', push_config1, context)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='task_1')
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+    assert len(result.configs) == 2
+    assert result.configs[0].task_id == 'task_1'
+    assert result.configs[0] == push_config1
+    assert result.configs[1].task_id == 'task_1'
+    assert result.configs[1] == push_config2
+
+
+@pytest.mark.asyncio
+async def test_list_task_push_notification_config_info_with_config_and_no_id():
+    """Test on_list_task_push_notification_configs with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(id='task_1', context_id='ctx_1')
+    push_store = InMemoryPushNotificationConfigStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    set_config_params1 = TaskPushNotificationConfig(
+        task_id='task_1', url='http://example.com'
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params1, create_server_call_context()
+    )
+    set_config_params2 = TaskPushNotificationConfig(
+        task_id='task_1', url='http://example.com'
+    )
+    await request_handler.on_create_task_push_notification_config(
+        set_config_params2, create_server_call_context()
+    )
+    params = ListTaskPushNotificationConfigsRequest(task_id='task_1')
+    result = await request_handler.on_list_task_push_notification_configs(
+        params, create_server_call_context()
+    )
+    assert len(result.configs) == 1
+    assert result.configs[0].task_id == 'task_1'
+    assert result.configs[0].url == set_config_params2.url
+    assert result.configs[0].id == 'task_1'
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_no_store():
+    """Test on_delete_task_push_notification_config when _push_config_store is None."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=AsyncMock(spec=TaskStore),
+        push_config_store=None,
+        agent_card=create_default_agent_card(),
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task1', id='config1'
+    )
+    with pytest.raises(PushNotificationNotSupportedError) as exc_info:
+        await request_handler.on_delete_task_push_notification_config(
+            params, create_server_call_context()
+        )
+    assert isinstance(exc_info.value, PushNotificationNotSupportedError)
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_task_not_found():
+    """Test on_delete_task_push_notification_config when task is not found."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = None
+    mock_push_store = AsyncMock(spec=PushNotificationConfigStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=mock_push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='non_existent_task', id='config1'
+    )
+    context = create_server_call_context()
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_delete_task_push_notification_config(
+            params, context
+        )
+    mock_task_store.get.assert_awaited_once_with('non_existent_task', context)
+    mock_push_store.get_info.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_delete_no_task_push_notification_config_info():
+    """Test on_delete_task_push_notification_config without config info"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='task_1')
+    mock_task_store.get.return_value = sample_task
+    push_store = InMemoryPushNotificationConfigStore()
+    await push_store.set_info(
+        'task_2',
+        TaskPushNotificationConfig(id='config_1', url='http://example.com'),
+        create_server_call_context(),
+    )
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task1', id='config_non_existant'
+    )
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result is None
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task2', id='config_non_existant'
+    )
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_info_with_config():
+    """Test on_list_task_push_notification_configs with push config+id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+    push_config1 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_1', url='http://example.com'
+    )
+    push_config2 = TaskPushNotificationConfig(
+        task_id='task_1', id='config_2', url='http://example.com'
+    )
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config1, context)
+    await push_store.set_info('task_1', push_config2, context)
+    await push_store.set_info('task_2', push_config1, context)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task_1', id='config_1'
+    )
+    result1 = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result1 is None
+    result2 = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task_1'),
+        create_server_call_context(),
+    )
+    assert len(result2.configs) == 1
+    assert result2.configs[0].task_id == 'task_1'
+    assert result2.configs[0] == push_config2
+
+
+@pytest.mark.asyncio
+async def test_delete_task_push_notification_config_info_with_config_and_no_id():
+    """Test on_list_task_push_notification_configs with no push config id"""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    sample_task = create_sample_task(task_id='non_existent_task')
+    mock_task_store.get.return_value = sample_task
+    push_config = TaskPushNotificationConfig(url='http://example.com')
+    push_store = InMemoryPushNotificationConfigStore()
+    context = create_server_call_context()
+    await push_store.set_info('task_1', push_config, context)
+    await push_store.set_info('task_1', push_config, context)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = DeleteTaskPushNotificationConfigRequest(
+        task_id='task_1', id='task_1'
+    )
+    result = await request_handler.on_delete_task_push_notification_config(
+        params, create_server_call_context()
+    )
+    assert result is None
+    result2 = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='task_1'),
+        create_server_call_context(),
+    )
+    assert len(result2.configs) == 0
+
+
+def create_input_mode_handler(*, validate_input_modes: bool):
+    """A handler whose card declares text/plain as its only input mode."""
+    return DefaultRequestHandlerV2(
+        # HelloAgentExecutor reaches a terminal state; MockAgentExecutor
+        # streams forever, so a blocking send against it never returns.
+        agent_executor=HelloAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=AgentCard(
+            name='test_agent',
+            version='1.0',
+            capabilities=AgentCapabilities(streaming=True),
+            default_input_modes=['text/plain'],
+        ),
+        validate_input_modes=validate_input_modes,
+    )
+
+
+def create_undeclared_media_type_request():
+    return SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_bad_media_type',
+            parts=[Part(text='hello', media_type='application/x-nope')],
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_rejects_undeclared_media_type_when_enabled():
+    handler = create_input_mode_handler(validate_input_modes=True)
+
+    with pytest.raises(ContentTypeNotSupportedError):
+        await handler.on_message_send(
+            create_undeclared_media_type_request(),
+            create_server_call_context(),
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_allows_undeclared_media_type_by_default():
+    """The check is opt-in, so an unflagged handler keeps accepting the part."""
+    handler = create_input_mode_handler(validate_input_modes=False)
+
+    result = await handler.on_message_send(
+        create_undeclared_media_type_request(), create_server_call_context()
+    )
+
+    assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_rejects_undeclared_media_type():
+    """Streaming shares _setup_active_task, so it is gated by the same flag."""
+    handler = create_input_mode_handler(validate_input_modes=True)
+
+    with pytest.raises(ContentTypeNotSupportedError):
+        async for _ in handler.on_message_send_stream(
+            create_undeclared_media_type_request(),
+            create_server_call_context(),
+        ):
+            pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_message_send_task_in_terminal_state(terminal_state):
+    """Test on_message_send when task is already in a terminal state."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'terminal_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = terminal_task
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_terminal',
+            parts=[Part(text='hello')],
+            task_id=task_id,
+        )
+    )
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=terminal_task,
+        ),
+        pytest.raises(UnsupportedOperationError) as exc_info,
+    ):
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_message_send_stream_task_in_terminal_state(terminal_state):
+    """Test on_message_send_stream when task is already in a terminal state."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'terminal_stream_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = terminal_task
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_terminal_stream',
+            parts=[Part(text='hello')],
+            task_id=task_id,
+        )
+    )
+    with (
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=terminal_task,
+        ),
+        pytest.raises(UnsupportedOperationError) as exc_info,
+    ):
+        async for _ in request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        ):
+            pass
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_rejects_context_id_not_matching_task():
+    """A contextId disagreeing with the named task's is rejected.
+
+    Asserted on the executor never running, not merely on the error type.
+    TaskManager already rejects this mismatch once the agent emits an event
+    (`Context in event doesn't match TaskManager`), so an assertion on
+    InvalidParamsError alone passes with or without the handler's guard.
+    What the guard changes is that the request is refused before any agent
+    work starts.
+    """
+    task = create_sample_task(task_id='task-1', context_id='real-context')
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = task
+    executor = HelloAgentExecutor()
+    executor.execute = AsyncMock(wraps=executor.execute)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=executor,
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-mismatch',
+            parts=[Part(text='hello')],
+            task_id='task-1',
+            context_id='wrong-context',
+        )
+    )
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+
+    assert (
+        'Context wrong-context does not match context real-context'
+        in exc_info.value.message
+    )
+    executor.execute.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_accepts_context_id_matching_task():
+    task = create_sample_task(task_id='task-1', context_id='real-context')
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = task
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-match',
+            parts=[Part(text='hello')],
+            task_id='task-1',
+            context_id='real-context',
+        )
+    )
+
+    assert (
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+        is not None
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_accepts_context_id_without_task_id():
+    """A contextId alone starts a new task in that context, so it is not checked."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg-context-only',
+            parts=[Part(text='hello')],
+            context_id='client-chosen-context',
+        )
+    )
+
+    assert (
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+        is not None
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('terminal_state', TERMINAL_TASK_STATES)
+async def test_on_subscribe_to_task_in_terminal_state(terminal_state):
+    """Subscribing to a terminal task is rejected with UnsupportedOperationError."""
+    state_name = TaskState.Name(terminal_state)
+    task_id = f'subscribe_terminal_task_{state_name}'
+    terminal_task = create_sample_task(
+        task_id=task_id, status_state=terminal_state
+    )
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = terminal_task
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+
+    with pytest.raises(UnsupportedOperationError) as exc_info:
+        async for _ in request_handler.on_subscribe_to_task(
+            SubscribeToTaskRequest(id=task_id), create_server_call_context()
+        ):
+            pass
+
+    assert (
+        f'Task {task_id} is in terminal state: {TaskState.Name(terminal_state)}'
+        in exc_info.value.message
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_task_id_provided_but_task_not_found():
+    """Test on_message_send when task_id is provided but task doesn't exist."""
+    pass
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_task_id_provided_but_task_not_found():
+    """Test on_message_send_stream when task_id is provided but task doesn't exist."""
+    pass
+
+
+class HelloWorldAgentExecutor(AgentExecutor):
+    """Test Agent Implementation."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        if context.message:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue,
+            task_id=context.task_id or str(uuid.uuid4()),
+            context_id=context.context_id or str(uuid.uuid4()),
+        )
+        await updater.update_status(TaskState.TASK_STATE_WORKING)
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        raise NotImplementedError('cancel not supported')
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_error_does_not_hang():
+    """Test that if the consumer raises an exception during blocking wait, the producer is cancelled and no deadlock occurs."""
+    agent = HelloWorldAgentExecutor()
+    task_store = AsyncMock(spec=TaskStore)
+    task_store.get.return_value = None
+    task_store.save.side_effect = RuntimeError('This is an Error!')
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_error_blocking',
+            parts=[Part(text='Test message')],
+        )
+    )
+    with pytest.raises(RuntimeError, match='This is an Error!'):
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_negative_history_length_error():
+    """Test on_get_task raises error for negative history length."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = GetTaskRequest(id='task1', history_length=-1)
+    context = create_server_call_context()
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_get_task(params, context)
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_page_size_too_small():
+    """Test on_list_tasks raises error for page_size < 1."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(page_size=0)
+    context = create_server_call_context()
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+    assert 'minimum page size is 1' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_list_tasks_page_size_too_large():
+    """Test on_list_tasks raises error for page_size > 100."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=AsyncMock(spec=AgentExecutor),
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = ListTasksRequest(page_size=101)
+    context = create_server_call_context()
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_list_tasks(params, context)
+    assert 'maximum page size is 100' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_negative_history_length_error():
+    """Test on_message_send raises error for negative history length in configuration."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        agent_card=create_default_agent_card(),
+    )
+    message_config = SendMessageConfiguration(
+        history_length=-1, accepted_output_modes=['text/plain']
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='msg1', parts=[Part(text='hello')]
+        ),
+        configuration=message_config,
+    )
+    context = create_server_call_context()
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await request_handler.on_message_send(params, context)
+    assert 'history length must be non-negative' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_limit_history():
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain'],
+            history_length=1,
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    # verify that history_length is honored
+    assert result is not None
+    assert isinstance(result, Task)
+    assert result.history is not None and len(result.history) == 1
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+
+    # verify that history is still persisted to the store
+    task = await task_store.get(result.id, context)
+    assert task is not None
+    assert task.history is not None and len(task.history) > 1
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_early_producer_exception_marks_task_failed_and_preserves_originating_message():
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_early_failure_state',
+            parts=[Part(text='Hi')],
+        )
+    )
+    context = create_server_call_context()
+    original_enqueue_event = EventQueueSource.enqueue_event
+
+    async def fail_before_request_started(self, event):
+        if type(event).__name__ == '_RequestStarted':
+            raise RuntimeError('early producer failure')
+        return await original_enqueue_event(self, event)
+
+    with patch.object(
+        EventQueueSource, 'enqueue_event', fail_before_request_started
+    ):
+        await send_message_with_early_failure(request_handler, params, context)
+
+    stored_task = await task_store.get(params.message.task_id, context)
+    assert stored_task is not None
+    assert stored_task.status.state == TaskState.TASK_STATE_FAILED
+    assert len(stored_task.history) == 1
+    assert stored_task.history[0].message_id == 'msg_early_failure_state'
+    assert stored_task.history[0].parts[0].text == 'Hi'
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'terminal_state',
+    [
+        TaskState.TASK_STATE_COMPLETED,
+        TaskState.TASK_STATE_CANCELED,
+    ],
+)
+async def test_on_message_send_late_producer_exception_preserves_persisted_terminal_state(
+    terminal_state: TaskState,
+):
+    task_store = InMemoryTaskStore()
+    terminal_state_persisted = asyncio.Event()
+    agent_executor = LateFailingTerminalAgentExecutor(
+        terminal_state, terminal_state_persisted
+    )
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_late_failure_terminal_state',
+            parts=[Part(text='Hi')],
+        )
+    )
+    context = create_server_call_context()
+    original_save_task = TaskManager._save_task
+
+    async def save_task_and_signal_terminal_state(self, task):
+        await original_save_task(self, task)
+        if task.status.state == terminal_state:
+            terminal_state_persisted.set()
+
+    with patch.object(
+        TaskManager, '_save_task', save_task_and_signal_terminal_state
+    ):
+        await request_handler.on_message_send(params, context)
+        await agent_executor.raised.wait()
+        await asyncio.sleep(0)
+
+    stored_task = await task_store.get(params.message.task_id, context)
+    assert stored_task is not None
+    assert stored_task.status.state == terminal_state
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_failure_right_after_task_is_recorded_on_that_task(
+    tmp_path,
+):
+    """The failure lands on the agent's Task, even while that Task is saving.
+
+    The executor raises while the store's save of its Task has looked the
+    task up but not yet inserted it: the window a database round trip
+    leaves open.
+    """
+    pytest.importorskip('sqlalchemy')
+    pytest.importorskip('aiosqlite')
+    from a2a.server.tasks.database_task_store import DatabaseTaskStore
+    from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+
+    engine = create_async_engine(f'sqlite+aiosqlite:///{tmp_path / "tasks.db"}')
+    task_store = DatabaseTaskStore(engine)
+    agent_executor = FailsAfterTaskAgentExecutor()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_failure_right_after_task',
+            parts=[Part(text='Hi')],
+        )
+    )
+    context = create_server_call_context()
+    original_merge = AsyncSession.merge
+    held = False
+
+    async def hold_agent_task_insert(self, instance, **kwargs):
+        nonlocal held
+        merged = await original_merge(self, instance, **kwargs)
+        if not held and 'agent_key' in (
+            getattr(instance, 'task_metadata', None) or {}
+        ):
+            held = True
+            agent_executor.may_raise.set()
+            # The failure path runs before this insert is flushed.
+            await asyncio.sleep(0.2)
+        return merged
+
+    try:
+        with patch.object(AsyncSession, 'merge', hold_agent_task_insert):
+            with pytest.raises(RuntimeError, match='model call failed'):
+                await request_handler.on_message_send(params, context)
+        assert agent_executor.task_id is not None
+        stored_task = await task_store.get(agent_executor.task_id, context)
+    finally:
+        await engine.dispose()
+
+    assert held
+    assert stored_task is not None
+    assert stored_task.status.state == TaskState.TASK_STATE_FAILED
+    assert stored_task.metadata['agent_key'] == 'kept'
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_failure_after_work_stamps_failure_time():
+    """A task failing after it reported progress is stamped when it failed."""
+    task_store = InMemoryTaskStore()
+    agent_executor = WorksThenFailsAgentExecutor()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_failure_after_work',
+            parts=[Part(text='Hi')],
+        )
+    )
+    context = create_server_call_context()
+
+    with pytest.raises(RuntimeError, match='model call failed'):
+        await request_handler.on_message_send(params, context)
+
+    assert agent_executor.task_id is not None
+    stored_task = await task_store.get(agent_executor.task_id, context)
+    assert stored_task is not None
+    assert stored_task.status.state == TaskState.TASK_STATE_FAILED
+    assert agent_executor.raised_at is not None
+    failed_at = stored_task.status.timestamp.ToDatetime(tzinfo=timezone.utc)
+    assert failed_at >= agent_executor.raised_at
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_failure_after_message_reply_marks_task_failed():
+    """A follow-up answered with a Message still fails the task on a raise."""
+    task_store = InMemoryTaskStore()
+    context = create_server_call_context()
+    task = Task(
+        id='task_awaiting_input',
+        context_id='ctx_awaiting_input',
+        status=TaskStatus(state=TaskState.TASK_STATE_INPUT_REQUIRED),
+    )
+    await task_store.save(task, context)
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=RepliesThenFailsAgentExecutor(),
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_follow_up',
+            parts=[Part(text='large')],
+            task_id=task.id,
+            context_id=task.context_id,
+        )
+    )
+
+    with pytest.raises(RuntimeError, match='model call failed'):
+        await request_handler.on_message_send(params, context)
+
+    stored_task = await task_store.get(task.id, context)
+    assert stored_task is not None
+    assert stored_task.status.state == TaskState.TASK_STATE_FAILED
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_failed_task_does_not_hide_producer_exception() -> (
+    None
+):
+    agent_executor = FailedStatusThenRaisesAgentExecutor()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=agent_executor,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_failed_then_raised',
+            parts=[Part(text='Hi')],
+        )
+    )
+
+    with pytest.raises(RuntimeError, match='late producer failure') as exc_info:
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
+    assert exc_info.value is agent_executor.exception
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_returns_agent_declared_failed_task() -> None:
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=FailedStatusAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_declared_failure',
+            parts=[Part(text='Hi')],
+        )
+    )
+
+    result = await request_handler.on_message_send(
+        params, create_server_call_context()
+    )
+
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_FAILED
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_early_producer_exception_preserves_originating_message():
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=EarlyFailingAgentExecutor(),
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_early_failure_history',
+            parts=[Part(text='Hi')],
+        )
+    )
+    context = create_server_call_context()
+
+    await send_message_with_early_failure(request_handler, params, context)
+
+    stored_task = await task_store.get(params.message.task_id, context)
+    assert stored_task is not None
+    assert stored_task.history is not None
+    assert len(stored_task.history) == 1
+    assert stored_task.history[0].message_id == 'msg_early_failure_history'
+    assert stored_task.history[0].parts[0].text == 'Hi'
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_task_id_mismatch():
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_agent_executor = AsyncMock(spec=AgentExecutor)
+    mock_request_context_builder = AsyncMock(spec=RequestContextBuilder)
+
+    context_task_id = 'context_task_id_stream_1'
+    result_task_id = 'DIFFERENT_task_id_stream_1'
+
+    mock_request_context = MagicMock()
+    mock_request_context.task_id = context_task_id
+    mock_request_context_builder.build.return_value = mock_request_context
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=mock_agent_executor,
+        task_store=mock_task_store,
+        request_context_builder=mock_request_context_builder,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_id_mismatch_stream',
+            parts=[Part(text='hello')],
+        )
+    )
+
+    mismatched_task = create_sample_task(task_id=result_task_id)
+
+    async def mock_subscribe(request=None, include_initial_task=False):
+        yield mismatched_task
+
+    mock_active_task = MagicMock()
+    mock_active_task.subscribe.side_effect = mock_subscribe
+    mock_active_task.start = AsyncMock()
+    mock_active_task.enqueue_request = AsyncMock()
+
+    with (
+        patch.object(
+            request_handler._active_task_registry,
+            'get_or_create',
+            return_value=mock_active_task,
+        ),
+        patch(
+            'a2a.server.request_handlers.default_request_handler.TaskManager.get_task',
+            return_value=None,
+        ),
+    ):
+        stream = request_handler.on_message_send_stream(
+            params, context=MagicMock()
+        )
+        with pytest.raises(InternalError) as exc_info:
+            async for _ in stream:
+                pass
+        assert 'Task ID mismatch' in exc_info.value.message
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_non_blocking():
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_non_blocking',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            return_immediately=True,
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    # non-blocking should return the task immediately
+    assert result is not None
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_SUBMITTED
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_with_push_notification():
+    task_store = InMemoryTaskStore()
+    push_store = AsyncMock(spec=PushNotificationConfigStore)
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    push_config = TaskPushNotificationConfig(url='http://example.com/webhook')
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_1',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            task_push_notification_config=push_config
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    assert result is not None
+    assert isinstance(result, Task)
+    push_store.set_info.assert_awaited_once_with(
+        result.id, push_config, context
+    )
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stores_inline_push_config_under_its_task():
+    task_store = InMemoryTaskStore()
+    push_store = InMemoryPushNotificationConfigStore()
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    # SendMessageConfiguration carries neither task_id nor id for the config.
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_inline',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            task_push_notification_config=TaskPushNotificationConfig(
+                url='http://example.com/webhook'
+            )
+        ),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    stored = await push_store.get_info(result.id, context)
+    assert [(config.task_id, config.id) for config in stored] == [
+        (result.id, result.id)
+    ]
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_with_empty_push_notification_config_does_not_call_set_info():
+    task_store = InMemoryTaskStore()
+    push_store = AsyncMock(spec=PushNotificationConfigStore)
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+    # Use empty SendMessageConfiguration where task_push_notification_config is NOT set explicitly.
+    # Proto3 makes accessing it return a truthy default instance.
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_empty',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(),
+    )
+
+    context = create_server_call_context()
+    result = await request_handler.on_message_send(params, context)
+
+    assert result is not None
+    assert isinstance(result, Task)
+    push_store.set_info.assert_not_called()
+
+
+class MultipleMessagesAgentExecutor(AgentExecutor):
+    """Misbehaving agent that yields more than one Message."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        await event_queue.enqueue_event(
+            new_text_message('first', role=Role.ROLE_AGENT)
+        )
+        await event_queue.enqueue_event(
+            new_text_message('second', role=Role.ROLE_AGENT)
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class MessageAfterTaskEventAgentExecutor(AgentExecutor):
+    """Misbehaving agent that yields a task-mode event then a Message."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.update_status(TaskState.TASK_STATE_WORKING)
+        await event_queue.enqueue_event(
+            new_text_message('stray message', role=Role.ROLE_AGENT)
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class TaskEventAfterMessageAgentExecutor(AgentExecutor):
+    """Misbehaving agent that yields a Message and then a task-mode event."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        await event_queue.enqueue_event(
+            new_text_message('only message', role=Role.ROLE_AGENT)
+        )
+        await event_queue.enqueue_event(
+            TaskStatusUpdateEvent(
+                task_id=str(context.task_id or ''),
+                context_id=str(context.context_id or ''),
+                status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            )
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class EventAfterTerminalStateAgentExecutor(AgentExecutor):
+    """Misbehaving agent that yields an event after reaching a terminal state."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.complete()
+        await event_queue.enqueue_event(
+            new_text_message('after terminal', role=Role.ROLE_AGENT)
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_stream_rejects_multiple_messages():
+    """Stream surfaces InvalidAgentResponseError when the agent yields a
+    second Message after the first one (see comment in on_message_send_stream)."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MultipleMessagesAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_multi_stream',
+            parts=[Part(text='Hi')],
+        )
+    )
+    with pytest.raises(InvalidAgentResponseError, match='Multiple Message'):
+        async for _ in request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        ):
+            pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_stream_rejects_message_after_task_event():
+    """Stream surfaces InvalidAgentResponseError when the agent yields a
+    Message after entering task mode (see comment in on_message_send_stream)."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MessageAfterTaskEventAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_after_task_stream',
+            parts=[Part(text='Hi')],
+        )
+    )
+    with pytest.raises(
+        InvalidAgentResponseError, match='Message object in task mode'
+    ):
+        async for _ in request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        ):
+            pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_stream_rejects_task_event_after_message():
+    """Stream surfaces InvalidAgentResponseError when the agent yields a
+    task-mode event after a Message (see comment in on_message_send_stream)."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=TaskEventAfterMessageAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_then_task_stream',
+            parts=[Part(text='Hi')],
+        )
+    )
+    with pytest.raises(InvalidAgentResponseError, match='in message mode'):
+        async for _ in request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        ):
+            pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.timeout(1)
+async def test_on_message_send_stream_rejects_event_after_terminal_state():
+    """Stream surfaces InvalidAgentResponseError when the agent yields an event
+    after reaching a terminal state (see comment in on_message_send_stream)."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=EventAfterTerminalStateAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_after_terminal_stream',
+            parts=[Part(text='Hi')],
+        )
+    )
+    with pytest.raises(
+        InvalidAgentResponseError, match='Message object in task mode'
+    ):
+        async for _ in request_handler.on_message_send_stream(
+            params, create_server_call_context()
+        ):
+            pass
+
+
+class _NamedUser(User):
+    """Minimal authenticated test user identified by ``user_name``."""
+
+    def __init__(self, user_name: str) -> None:
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def _ctx(user_name: str) -> ServerCallContext:
+    return ServerCallContext(user=_NamedUser(user_name))
+
+
+@pytest.mark.asyncio
+async def test_on_list_task_push_notification_configs_is_owner_scoped():
+    """v2 handler: Bob must not see Alice's configs via .../list."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(
+        id='shared-task', context_id='ctx_1'
+    )
+
+    push_store = InMemoryPushNotificationConfigStore()
+    alice_ctx = _ctx('alice')
+    bob_ctx = _ctx('bob')
+
+    alice_cfg = TaskPushNotificationConfig(
+        task_id='shared-task',
+        id='alice-cfg',
+        url='http://alice.example.com/cb',
+        token='alice-secret',
+    )
+    bob_cfg = TaskPushNotificationConfig(
+        task_id='shared-task',
+        id='bob-cfg',
+        url='http://bob.example.com/cb',
+        token='bob-secret',
+    )
+    await push_store.set_info('shared-task', alice_cfg, alice_ctx)
+    await push_store.set_info('shared-task', bob_cfg, bob_ctx)
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+
+    alice_listing = (
+        await request_handler.on_list_task_push_notification_configs(
+            ListTaskPushNotificationConfigsRequest(task_id='shared-task'),
+            alice_ctx,
+        )
+    )
+    assert {c.id for c in alice_listing.configs} == {'alice-cfg'}
+    assert all(c.token != 'bob-secret' for c in alice_listing.configs)
+
+    bob_listing = await request_handler.on_list_task_push_notification_configs(
+        ListTaskPushNotificationConfigsRequest(task_id='shared-task'),
+        bob_ctx,
+    )
+    assert {c.id for c in bob_listing.configs} == {'bob-cfg'}
+    assert all(c.token != 'alice-secret' for c in bob_listing.configs)
+
+
+@pytest.mark.asyncio
+async def test_on_get_task_push_notification_config_is_owner_scoped():
+    """v2 handler: Bob cannot fetch Alice's config by ID via .../get."""
+    mock_task_store = AsyncMock(spec=TaskStore)
+    mock_task_store.get.return_value = Task(
+        id='shared-task', context_id='ctx_1'
+    )
+
+    push_store = InMemoryPushNotificationConfigStore()
+    alice_ctx = _ctx('alice')
+    await push_store.set_info(
+        'shared-task',
+        TaskPushNotificationConfig(
+            task_id='shared-task',
+            id='alice-cfg',
+            url='http://alice.example.com/cb',
+            token='alice-secret',
+        ),
+        alice_ctx,
+    )
+
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=mock_task_store,
+        push_config_store=push_store,
+        agent_card=create_default_agent_card(),
+    )
+
+    alice_view = await request_handler.on_get_task_push_notification_config(
+        GetTaskPushNotificationConfigRequest(
+            task_id='shared-task', id='alice-cfg'
+        ),
+        alice_ctx,
+    )
+    assert alice_view.id == 'alice-cfg'
+    assert alice_view.token == 'alice-secret'
+
+    with pytest.raises(TaskNotFoundError):
+        await request_handler.on_get_task_push_notification_config(
+            GetTaskPushNotificationConfigRequest(
+                task_id='shared-task', id='alice-cfg'
+            ),
+            _ctx('bob'),
+        )
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_drains_registry():
+    """aclose() drains the active-task registry on shutdown."""
+    handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    await handler._active_task_registry.get_or_create(
+        'task-1',
+        call_context=ServerCallContext(user=UnauthenticatedUser()),
+        create_task_if_missing=True,
+    )
+
+    await handler.aclose()
+
+    assert await handler._active_task_registry.get('task-1') is None
+
+
+@pytest.mark.timeout(5)
+@pytest.mark.asyncio
+async def test_aclose_is_idempotent_and_handles_empty():
+    """aclose() is safe with no active tasks and when called twice."""
+    handler = DefaultRequestHandlerV2(
+        agent_executor=MockAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+
+    await handler.aclose()
+    await handler.aclose()
+
+
+# --- Issue #1159: SubscribeToTask / CancelTask must be owner-scoped even when
+# the task is LIVE in the ActiveTaskRegistry (the cached-active path that
+# previously skipped the owner-aware TaskStore). ------------------------------
+
+
+class _HangingAgent(AgentExecutor):
+    """Stays in ``working`` so the task remains live in the registry.
+
+    ``cancel`` writes a terminal CANCELED state, so a legitimate owner cancel
+    resolves the same way regardless of the #1170 fix.
+    """
+
+    def __init__(self) -> None:
+        self.working = asyncio.Event()
+        self.release = asyncio.Event()
+        self.cancel_called = asyncio.Event()
+        self.cancel_metadata: dict[str, Any] | None = None
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.update_status(TaskState.TASK_STATE_WORKING)
+        self.working.set()
+        await self.release.wait()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        self.cancel_metadata = context.metadata
+        self.cancel_called.set()
+        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
+        await updater.cancel()
+
+
+class _ParkThenHangAgent(AgentExecutor):
+    """Parks the task in the non-terminal ``input-required`` state and keeps
+    the producer alive, so the ActiveTask stays in the registry. ``cancel`` is
+    cleanup-only (writes no terminal state)."""
+
+    def __init__(self) -> None:
+        self.parked = asyncio.Event()
+        self.release = asyncio.Event()
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.update_status(TaskState.TASK_STATE_INPUT_REQUIRED)
+        self.parked.set()
+        await self.release.wait()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+async def _start_live_task(handler, ctx, text):
+    task = await handler.on_message_send(
+        SendMessageRequest(
+            message=Message(
+                message_id=f'msg-{text}',
+                role=Role.ROLE_USER,
+                parts=[Part(text=text)],
+            ),
+            configuration=SendMessageConfiguration(return_immediately=True),
+        ),
+        ctx,
+    )
+    return task.id
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_cancel_task_is_owner_scoped_for_live_task():
+    """Issue #1159: a non-owner must not cancel another user's LIVE task."""
+    agent = _HangingAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    alice = _ctx('alice')
+    bob = _ctx('bob')
+
+    task_id = await _start_live_task(handler, alice, 'work')
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+    # The task is live in the registry -> exercises the cached-active path.
+    assert await handler._active_task_registry.get(task_id) is not None
+
+    # Bob (non-owner) is rejected, masked as not-found, and never reaches the
+    # executor's cancel().
+    with pytest.raises(TaskNotFoundError):
+        await handler.on_cancel_task(CancelTaskRequest(id=task_id), bob)
+    assert not agent.cancel_called.is_set()
+
+    # Alice (owner) can still cancel her own task.
+    result = await handler.on_cancel_task(CancelTaskRequest(id=task_id), alice)
+    assert result.status.state == TaskState.TASK_STATE_CANCELED
+    assert agent.cancel_called.is_set()
+
+    agent.release.set()
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_cancel_task_forwards_metadata_to_executor() -> None:
+    """Issue #1415: CancelTaskRequest.metadata reaches AgentExecutor.cancel."""
+    agent = _HangingAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    alice = _ctx('alice')
+
+    task_id = await _start_live_task(handler, alice, 'work')
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+
+    result = await handler.on_cancel_task(
+        CancelTaskRequest(
+            id=task_id,
+            metadata={'reason': 'user_aborted', 'actor': 'alice'},
+        ),
+        alice,
+    )
+    assert result is not None
+    assert result.status.state == TaskState.TASK_STATE_CANCELED
+    assert agent.cancel_metadata == {
+        'reason': 'user_aborted',
+        'actor': 'alice',
+    }
+
+    agent.release.set()
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_is_owner_scoped_for_live_task():
+    """Issue #1159: a non-owner must not subscribe to another user's LIVE task."""
+    agent = _HangingAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    alice = _ctx('alice')
+    bob = _ctx('bob')
+
+    task_id = await _start_live_task(handler, alice, 'work')
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+    assert await handler._active_task_registry.get(task_id) is not None
+
+    # Bob (non-owner) is rejected on the first iteration of the stream.
+    with pytest.raises(TaskNotFoundError):
+        async for _ in handler.on_subscribe_to_task(
+            SubscribeToTaskRequest(id=task_id), bob
+        ):
+            break
+
+    # Alice (owner) can subscribe and receives her own task.
+    received = None
+    async for event in handler.on_subscribe_to_task(
+        SubscribeToTaskRequest(id=task_id), alice
+    ):
+        received = event
+        break
+    assert received is not None
+    assert getattr(received, 'id', None) == task_id
+
+    agent.release.set()
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_cancel_of_parked_task_is_owner_scoped():
+    """Issue #1159 x #1170: a non-owner cancel of another user's PARKED
+    (input-required) live task must be rejected and must NOT write a terminal
+    CANCELED state. This is the exact cross-tenant regression the #1170 fix
+    (cancel writes a terminal state) would otherwise expose on the un-guarded
+    cached-active path."""
+    agent = _ParkThenHangAgent()
+    store = InMemoryTaskStore()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=store,
+        agent_card=create_default_agent_card(),
+    )
+    alice = _ctx('alice')
+    bob = _ctx('bob')
+
+    task_id = await _start_live_task(handler, alice, 'park')
+    await asyncio.wait_for(agent.parked.wait(), timeout=5)
+    assert await handler._active_task_registry.get(task_id) is not None
+
+    # update_status enqueues the input-required transition; wait until it is
+    # persisted to the store before the cross-tenant cancel so the assertions
+    # below do not race the event pipeline.
+    alice_view = None
+    for _ in range(500):
+        alice_view = await store.get(task_id, alice)
+        if (
+            alice_view is not None
+            and alice_view.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+        ):
+            break
+        await asyncio.sleep(0.01)
+    assert alice_view is not None
+    assert alice_view.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    # Bob (non-owner) is rejected...
+    with pytest.raises(TaskNotFoundError):
+        await handler.on_cancel_task(CancelTaskRequest(id=task_id), bob)
+
+    # ...and Alice's task is untouched: still input-required, not CANCELED.
+    alice_view = await store.get(task_id, alice)
+    assert alice_view is not None
+    assert alice_view.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+
+    agent.release.set()
+    await handler.aclose()
+
+
+class _ReleaseThenCompleteAgent(_HangingAgent):
+    """Like ``_HangingAgent``, but completes the task once released."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.task_id: str | None = None
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        self.task_id = context.task_id
+        await super().execute(context, event_queue)
+        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
+        await updater.complete()
+
+
+async def _wait_for_task_state(handler, task_id, ctx, state) -> None:
+    async def poll() -> None:
+        while True:
+            task = await handler.on_get_task(GetTaskRequest(id=task_id), ctx)
+            if task.status.state == state:
+                return
+            await asyncio.sleep(0.01)
+
+    await asyncio.wait_for(poll(), timeout=5)
+
+
+async def _assert_task_survives(handler, agent, ctx) -> None:
+    """The task keeps running after its caller goes away and still finishes."""
+    assert agent.task_id is not None
+    await asyncio.sleep(0.1)
+    assert not agent.cancel_called.is_set()
+    assert await handler._active_task_registry.get(agent.task_id) is not None
+
+    agent.release.set()
+    await _wait_for_task_state(
+        handler, agent.task_id, ctx, TaskState.TASK_STATE_COMPLETED
+    )
+
+
+def _hanging_send_request(text: str) -> SendMessageRequest:
+    return SendMessageRequest(
+        message=Message(
+            message_id=f'msg-{text}',
+            role=Role.ROLE_USER,
+            parts=[Part(text=text)],
+        )
+    )
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_message_send_wait_for_times_out_while_task_works():
+    """A caller timeout on a blocking send raises instead of returning the
+    unfinished task."""
+    agent = _HangingAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(
+            handler.on_message_send(
+                _hanging_send_request('timeout'), create_server_call_context()
+            ),
+            timeout=0.5,
+        )
+
+    agent.release.set()
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_message_send_propagates_caller_cancellation():
+    """Cancelling the task that awaits a blocking send cancels it, and only
+    it: the agent keeps running."""
+    agent = _ReleaseThenCompleteAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    ctx = create_server_call_context()
+
+    send = asyncio.create_task(
+        handler.on_message_send(_hanging_send_request('cancel'), ctx)
+    )
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+    send.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await send
+    assert send.cancelled()
+
+    await _assert_task_survives(handler, agent, ctx)
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_message_send_stream_propagates_consumer_cancellation():
+    """Cancelling a stream consumer cancels it instead of ending the stream
+    as if the task had finished, and leaves the agent running."""
+    agent = _ReleaseThenCompleteAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    ctx = create_server_call_context()
+
+    async def consume() -> None:
+        async for _ in handler.on_message_send_stream(
+            _hanging_send_request('stream'), ctx
+        ):
+            pass
+
+    reader = asyncio.create_task(consume())
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+    reader.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await reader
+    assert reader.cancelled()
+
+    await _assert_task_survives(handler, agent, ctx)
+    await handler.aclose()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_on_subscribe_to_task_propagates_consumer_cancellation():
+    """Cancelling one resubscriber cancels only that consumer. The task and
+    the other subscriber keep going until the task completes."""
+    agent = _ReleaseThenCompleteAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    ctx = create_server_call_context()
+
+    task_id = await _start_live_task(handler, ctx, 'resubscribe')
+    await asyncio.wait_for(agent.working.wait(), timeout=5)
+
+    def subscriber() -> tuple[asyncio.Task, list[Event], asyncio.Event]:
+        events: list[Event] = []
+        attached = asyncio.Event()
+
+        async def consume() -> None:
+            async for event in handler.on_subscribe_to_task(
+                SubscribeToTaskRequest(id=task_id), ctx
+            ):
+                events.append(event)
+                attached.set()
+
+        return asyncio.create_task(consume()), events, attached
+
+    cancelled, _, cancelled_attached = subscriber()
+    other, other_events, other_attached = subscriber()
+    await asyncio.wait_for(cancelled_attached.wait(), timeout=5)
+    await asyncio.wait_for(other_attached.wait(), timeout=5)
+
+    cancelled.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await cancelled
+    assert cancelled.cancelled()
+    assert not other.done()
+
+    await _assert_task_survives(handler, agent, ctx)
+
+    await asyncio.wait_for(other, timeout=5)
+    last = other_events[-1]
+    assert isinstance(last, TaskStatusUpdateEvent)
+    assert last.status.state == TaskState.TASK_STATE_COMPLETED
+
+    await handler.aclose()
+
+
+class _AsksForInputAgent(AgentExecutor):
+    """Always asks for more input; counts execute() and cancel() calls."""
+
+    def __init__(self) -> None:
+        self.execute_calls = 0
+        self.cancel_calls = 0
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        self.execute_calls += 1
+        if context.current_task is None:
+            await event_queue.enqueue_event(
+                new_task_from_user_message(context.message)
+            )
+        updater = TaskUpdater(
+            event_queue, context.task_id or '', context.context_id or ''
+        )
+        await updater.requires_input(
+            message=updater.new_agent_message([Part(text='need input')])
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        self.cancel_calls += 1
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_cancel_of_input_required_task_cannot_be_undone():
+    """Cancelling a task that waits for input cancels the agent, drops the
+    ActiveTask, and a follow-up message cannot revive the task."""
+    agent = _AsksForInputAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    ctx = _ctx('alice')
+    task = await handler.on_message_send(
+        SendMessageRequest(
+            message=Message(
+                role=Role.ROLE_USER, message_id='m1', parts=[Part(text='hi')]
+            )
+        ),
+        ctx,
+    )
+    assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    # Wait until the turn has fully ended and the task is parked for input.
+    active = await handler._active_task_registry.get(task.id)
+    assert active is not None
+    for _ in range(100):
+        if not active._request_lock.locked():
+            break
+        await asyncio.sleep(0.01)
+    assert not active._request_lock.locked()
+
+    cancelled = await handler.on_cancel_task(CancelTaskRequest(id=task.id), ctx)
+    assert cancelled.status.state == TaskState.TASK_STATE_CANCELED
+    assert agent.cancel_calls == 1
+    for _ in range(100):
+        if await handler._active_task_registry.get(task.id) is None:
+            break
+        await asyncio.sleep(0.01)
+    assert await handler._active_task_registry.get(task.id) is None
+
+    follow_up = Message(
+        role=Role.ROLE_USER,
+        message_id='m2',
+        parts=[Part(text='more')],
+        task_id=task.id,
+        context_id=task.context_id,
+    )
+    with pytest.raises(UnsupportedOperationError, match='terminal state'):
+        await handler.on_message_send(
+            SendMessageRequest(message=follow_up), ctx
+        )
+
+    stored = await handler.on_get_task(GetTaskRequest(id=task.id), ctx)
+    assert stored.status.state == TaskState.TASK_STATE_CANCELED
+    assert agent.execute_calls == 1
+    await handler.aclose()
+
+
+_REQUEST_TAG: contextvars.ContextVar[str] = contextvars.ContextVar(
+    'request_tag', default='unset'
+)
+
+
+class _InputRequiredThenCompleteAgent(AgentExecutor):
+    """Asks for input on the first message of a task and completes on the next."""
+
+    def __init__(self) -> None:
+        self.seen_tags: list[str] = []
+        self.task: Task | None = None
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        self.seen_tags.append(_REQUEST_TAG.get())
+        if context.current_task:
+            updater = TaskUpdater(
+                event_queue, context.task_id, context.context_id
+            )
+            await updater.complete()
+            return
+        self.task = new_task_from_user_message(context.message)
+        await event_queue.enqueue_event(self.task)
+        updater = TaskUpdater(event_queue, self.task.id, self.task.context_id)
+        await updater.update_status(TaskState.TASK_STATE_INPUT_REQUIRED)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+@pytest.mark.parametrize('streaming', [False, True])
+async def test_follow_up_message_runs_in_sender_contextvars(streaming):
+    """A follow-up message on a live task must see its own request's contextvars."""
+    agent = _InputRequiredThenCompleteAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+
+    async def send(tag: str, message: Message) -> None:
+        _REQUEST_TAG.set(tag)
+        params = SendMessageRequest(message=message)
+        if streaming:
+            async for _ in handler.on_message_send_stream(
+                params, create_server_call_context()
+            ):
+                pass
+        else:
+            await handler.on_message_send(params, create_server_call_context())
+
+    await asyncio.create_task(
+        send(
+            'request-1',
+            Message(
+                message_id='msg-1',
+                role=Role.ROLE_USER,
+                parts=[Part(text='book a flight')],
+            ),
+        )
+    )
+    assert agent.task is not None
+    await asyncio.create_task(
+        send(
+            'request-2',
+            Message(
+                message_id='msg-2',
+                role=Role.ROLE_USER,
+                parts=[Part(text='Friday')],
+                task_id=agent.task.id,
+                context_id=agent.task.context_id,
+            ),
+        )
+    )
+
+    assert agent.seen_tags == ['request-1', 'request-2']
+    await handler.aclose()
+
+
+class _ContextRecordingAgent(AgentExecutor):
+    """Records the context id each execution is handed."""
+
+    def __init__(self) -> None:
+        self.seen_context_ids: list[str | None] = []
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        self.seen_context_ids.append(context.context_id)
+        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
+        await updater.complete()
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('streaming', [False, True])
+async def test_task_only_message_infers_context_id_from_task(streaming):
+    """A2A 3.4.3: a message naming only a taskId inherits the task's context."""
+    agent = _ContextRecordingAgent()
+    task_store = InMemoryTaskStore()
+    call_context = create_server_call_context()
+    task = Task(
+        id='task-awaiting-input',
+        context_id='ctx-from-stored-task',
+        status=TaskStatus(state=TaskState.TASK_STATE_INPUT_REQUIRED),
+    )
+    await task_store.save(task, call_context)
+    handler = DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=task_store,
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            message_id='msg-follow-up',
+            role=Role.ROLE_USER,
+            parts=[Part(text='aaa')],
+            task_id=task.id,
+        )
+    )
+
+    if streaming:
+        events = [
+            event
+            async for event in handler.on_message_send_stream(
+                params, call_context
+            )
+        ]
+    else:
+        events = [await handler.on_message_send(params, call_context)]
+
+    assert agent.seen_context_ids == [task.context_id]
+    assert events
+    assert all(event.context_id == task.context_id for event in events)
+    assert params.message.context_id == task.context_id
+    stored = await task_store.get(task.id, call_context)
+    assert stored is not None
+    assert stored.context_id == task.context_id
+    await handler.aclose()
+
+
+def _complete_agent_card() -> AgentCard:
+    """Returns an AgentCard with every field the A2A spec marks REQUIRED."""
+    return AgentCard(
+        name='complete_agent',
+        description='An agent card with all required fields.',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://localhost:8000',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            )
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            AgentSkill(
+                id='echo',
+                name='Echo',
+                description='Echoes the input.',
+                tags=['test'],
+            )
+        ],
+    )
+
+
+def test_init_warns_about_incomplete_agent_cards(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Cards missing REQUIRED fields are accepted, but each one is logged."""
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        DefaultRequestHandlerV2(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=create_default_agent_card(),
+            extended_agent_card=AgentCard(),
+        )
+    messages = [record.getMessage() for record in caplog.records]
+    assert len(messages) == 2
+    assert messages[0].startswith(
+        'agent_card passed to DefaultRequestHandlerV2:'
+    )
+    assert messages[1].startswith(
+        'extended_agent_card passed to DefaultRequestHandlerV2:'
+    )
+
+
+def test_init_does_not_warn_for_complete_agent_cards(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        DefaultRequestHandlerV2(
+            agent_executor=MockAgentExecutor(),
+            task_store=InMemoryTaskStore(),
+            agent_card=_complete_agent_card(),
+            extended_agent_card=_complete_agent_card(),
+        )
+    assert caplog.records == []
+
+
+class FlakyPushConfigStore(InMemoryPushNotificationConfigStore):
+    """Config store whose dispatch read fails transiently (issue #1313)."""
+
+    async def get_info_for_dispatch(
+        self, task_id: str
+    ) -> list[TaskPushNotificationConfig]:
+        raise RuntimeError('transient DB error while reading push configs')
+
+
+class RaisingPushSender(PushNotificationSender):
+    """A custom (public-interface) sender that always fails (issue #1313)."""
+
+    async def send_notification(self, task_id, event) -> None:
+        raise RuntimeError('sender exploded')
+
+
+@pytest.mark.asyncio
+async def test_push_config_store_failure_does_not_fail_task():
+    """A push-notification infrastructure failure must not rewrite a
+    successfully completed task as FAILED, and message/send must still
+    return the task result (#1313)."""
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_config_store=FlakyPushConfigStore(),
+        push_sender=BasePushNotificationSender(
+            httpx_client=AsyncMock(spec=httpx.AsyncClient),
+            config_store=FlakyPushConfigStore(),
+        ),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_store_fail',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+
+    result = await request_handler.on_message_send(
+        params, create_server_call_context()
+    )
+
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    get_task_result = await request_handler.on_get_task(
+        GetTaskRequest(id=result.id), create_server_call_context()
+    )
+    assert get_task_result is not None
+    assert isinstance(get_task_result, Task)
+    assert get_task_result.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_custom_push_sender_failure_does_not_fail_task():
+    """A raising custom PushNotificationSender must not rewrite a
+    completed task as FAILED — the consumer-level guard is
+    defense-in-depth behind the BasePushNotificationSender boundary
+    (#1313)."""
+    task_store = InMemoryTaskStore()
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=HelloAgentExecutor(),
+        task_store=task_store,
+        push_sender=RaisingPushSender(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_push_sender_fail',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+
+    result = await request_handler.on_message_send(
+        params, create_server_call_context()
+    )
+
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    get_task_result = await request_handler.on_get_task(
+        GetTaskRequest(id=result.id), create_server_call_context()
+    )
+    assert get_task_result is not None
+    assert isinstance(get_task_result, Task)
+    assert get_task_result.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+class _MessageOnlyAgent(AgentExecutor):
+    """Answers every request with a single direct Message (no task)."""
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        await event_queue.enqueue_event(new_text_message('hello'))
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+async def _wait_until_released(
+    handler: DefaultRequestHandlerV2, baseline: set[asyncio.Task]
+) -> set[asyncio.Task]:
+    """Waits for the handler to drop its ActiveTasks; returns tasks still pending."""
+    leftover: set[asyncio.Task] = set()
+    for _ in range(100):
+        leftover = asyncio.all_tasks() - baseline - {asyncio.current_task()}
+        if not handler._active_task_registry._active_tasks and not leftover:
+            break
+        await asyncio.sleep(0.01)
+    return leftover
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_message_response_releases_active_task() -> None:
+    """A direct Message ends the interaction, so its ActiveTask (producer,
+    consumer, dispatchers) must not stay alive waiting for a follow-up."""
+    handler = DefaultRequestHandlerV2(
+        agent_executor=_MessageOnlyAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    baseline = asyncio.all_tasks()
+
+    for i in range(3):
+        result = await handler.on_message_send(
+            SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id=f'm{i}',
+                    parts=[Part(text='hi')],
+                )
+            ),
+            ServerCallContext(),
+        )
+        assert isinstance(result, Message)
+
+    assert await _wait_until_released(handler, baseline) == set()
+    assert handler._active_task_registry._active_tasks == {}
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_stream_message_response_releases_active_task() -> (
+    None
+):
+    """Same for a message-only stream: one Message, then nothing left running."""
+    handler = DefaultRequestHandlerV2(
+        agent_executor=_MessageOnlyAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    baseline = asyncio.all_tasks()
+
+    events = [
+        event
+        async for event in handler.on_message_send_stream(
+            SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id='m1',
+                    parts=[Part(text='hi')],
+                )
+            ),
+            ServerCallContext(),
+        )
+    ]
+
+    assert [type(event) for event in events] == [Message]
+    assert await _wait_until_released(handler, baseline) == set()
+    assert handler._active_task_registry._active_tasks == {}
+
+
+class _InterruptingAgent(AgentExecutor):
+    """Interrupts a new task with `state`; completes it on the follow-up."""
+
+    def __init__(
+        self,
+        state: TaskState = TaskState.TASK_STATE_INPUT_REQUIRED,
+        complete_on_follow_up: bool = True,
+        linger: float = 0,
+    ) -> None:
+        self.state = state
+        self.complete_on_follow_up = complete_on_follow_up
+        self.linger = linger
+
+    async def execute(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        if context.current_task is None:
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+            task_id, context_id = task.id, task.context_id
+        else:
+            task_id, context_id = context.task_id, context.context_id
+        updater = TaskUpdater(event_queue, task_id, context_id)
+        if context.current_task is not None and self.complete_on_follow_up:
+            await updater.complete()
+            return
+        await updater.update_status(self.state)
+        # Keeps the request running after the interruption was delivered.
+        await asyncio.sleep(self.linger)
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        pass
+
+
+def _interrupting_handler(
+    agent: AgentExecutor, interrupted_task_timeout: float | None
+) -> DefaultRequestHandlerV2:
+    return DefaultRequestHandlerV2(
+        agent_executor=agent,
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+        interrupted_task_timeout=interrupted_task_timeout,
+    )
+
+
+async def _send(
+    handler: DefaultRequestHandlerV2, text: str, task: Task | None = None
+) -> Task:
+    message = Message(
+        message_id=str(uuid.uuid4()),
+        role=Role.ROLE_USER,
+        parts=[Part(text=text)],
+        task_id=task.id if task else '',
+        context_id=task.context_id if task else '',
+    )
+    result = await handler.on_message_send(
+        SendMessageRequest(message=message), create_server_call_context()
+    )
+    assert isinstance(result, Task)
+    return result
+
+
+async def _wait_for_release(
+    handler: DefaultRequestHandlerV2, task_id: str, timeout: float = 2.0
+) -> bool:
+    """Waits until the task's ActiveTask has left the registry."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if task_id not in handler._active_task_registry._active_tasks:
+            return True
+        await asyncio.sleep(0.01)
+    return False
+
+
+@pytest.mark.asyncio
+async def test_interrupted_task_stays_active_without_timeout() -> None:
+    """The default keeps today's behavior: no timeout, the ActiveTask waits."""
+    handler = _interrupting_handler(_InterruptingAgent(), None)
+
+    task = await _send(handler, 'book a flight')
+
+    assert not await _wait_for_release(handler, task.id, timeout=0.3)
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'state',
+    [TaskState.TASK_STATE_INPUT_REQUIRED, TaskState.TASK_STATE_AUTH_REQUIRED],
+)
+async def test_interrupted_task_released_after_timeout(
+    state: TaskState,
+) -> None:
+    """A parked task's runtime is released, but the stored task is kept."""
+    handler = _interrupting_handler(_InterruptingAgent(state), 0.1)
+    baseline = asyncio.all_tasks()
+
+    task = await _send(handler, 'book a flight')
+
+    assert task.status.state == state
+    assert await _wait_for_release(handler, task.id)
+    leftover: set[asyncio.Task] = set()
+    for _ in range(100):
+        leftover = asyncio.all_tasks() - baseline - {asyncio.current_task()}
+        if not leftover:
+            break
+        await asyncio.sleep(0.01)
+    assert leftover == set()
+    stored = await handler.on_get_task(
+        GetTaskRequest(id=task.id), create_server_call_context()
+    )
+    assert stored is not None
+    assert stored.status.state == state
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_follow_up_after_release_resumes_from_store() -> None:
+    """A follow-up to a released task recreates its ActiveTask from the store."""
+    handler = _interrupting_handler(_InterruptingAgent(), 0.1)
+    task = await _send(handler, 'book a flight')
+    assert await _wait_for_release(handler, task.id)
+
+    result = await _send(handler, 'Friday', task)
+
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    assert [m.parts[0].text for m in result.history] == [
+        'book a flight',
+        'Friday',
+    ]
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_follow_up_resets_interrupted_task_timeout() -> None:
+    """A follow-up that interrupts again restarts the timer."""
+    handler = _interrupting_handler(
+        _InterruptingAgent(complete_on_follow_up=False), 0.5
+    )
+    task = await _send(handler, 'book a flight')
+    await asyncio.sleep(0.3)
+
+    await _send(handler, 'Friday', task)
+
+    # 0.6s after the first request, but only 0.3s after the follow-up.
+    assert not await _wait_for_release(handler, task.id, timeout=0.3)
+    assert await _wait_for_release(handler, task.id)
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_subscriber_keeps_interrupted_task_active() -> None:
+    """The timer only counts while no subscriber is attached."""
+    handler = _interrupting_handler(_InterruptingAgent(), 0.1)
+    task = await _send(handler, 'book a flight')
+
+    subscription = handler.on_subscribe_to_task(
+        SubscribeToTaskRequest(id=task.id), create_server_call_context()
+    )
+    await anext(subscription)
+    assert not await _wait_for_release(handler, task.id, timeout=0.3)
+
+    await subscription.aclose()
+    assert await _wait_for_release(handler, task.id)
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_running_request_keeps_interrupted_task_active() -> None:
+    """The timer only counts once the executor has returned."""
+    handler = _interrupting_handler(_InterruptingAgent(linger=0.4), 0.1)
+    task = await _send(handler, 'book a flight')
+
+    assert not await _wait_for_release(handler, task.id, timeout=0.3)
+    assert await _wait_for_release(handler, task.id)
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_follow_up_replaces_finished_registered_active_task() -> None:
+    """A finished ActiveTask still in the registry must not reject a follow-up."""
+    handler = _interrupting_handler(_InterruptingAgent(), None)
+    task = await _send(handler, 'book a flight')
+    active_task = handler._active_task_registry._active_tasks[task.id]
+    # Finish it the way a release does, before its registry cleanup has run.
+    active_task._is_finished.set()
+    active_task._request_queue.shutdown(immediate=True)
+
+    result = await _send(handler, 'Friday', task)
+
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    await handler.aclose()
+
+
+@pytest.mark.parametrize('timeout', [0, -1])
+def test_interrupted_task_timeout_must_be_positive(timeout: float) -> None:
+    """A timeout of 0 or less is rejected."""
+    with pytest.raises(ValueError, match='greater than 0'):
+        _interrupting_handler(_InterruptingAgent(), timeout)
+
+
+@pytest.mark.asyncio
+async def test_near_zero_timeout_releases_and_resumes() -> None:
+    """A tiny timeout releases right after the request; a follow-up resumes."""
+    handler = _interrupting_handler(_InterruptingAgent(), 1e-9)
+    task = await _send(handler, 'book a flight')
+
+    assert task.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert await _wait_for_release(handler, task.id)
+    result = await _send(handler, 'Friday', task)
+
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_cancels_idle_release() -> None:
+    """Resolving a parked task for a request stops its timer."""
+    handler = _interrupting_handler(_InterruptingAgent(), 0.2)
+    task = await _send(handler, 'book a flight')
+    # Lets the first request's cleanup start the timer before it is cancelled.
+    await asyncio.sleep(0.05)
+    registry = handler._active_task_registry
+
+    active_task = await registry.get_or_create(
+        task.id, call_context=create_server_call_context()
+    )
+
+    assert active_task._idle_release_task is None
+    assert not await _wait_for_release(handler, task.id, timeout=0.5)
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_idle_release_check_failure_keeps_task(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """A failing store read is logged and leaves the task in place."""
+    handler = _interrupting_handler(_InterruptingAgent(), 0.1)
+    task = await _send(handler, 'book a flight')
+    active_task = handler._active_task_registry._active_tasks[task.id]
+
+    with patch.object(
+        active_task._task_manager,
+        'get_task',
+        AsyncMock(side_effect=RuntimeError('store down')),
+    ):
+        assert not await _wait_for_release(handler, task.id, timeout=0.3)
+
+    assert 'Idle release check failed' in caplog.text
+    await handler.aclose()
+
+
+@pytest.mark.asyncio
+async def test_failed_cancel_restarts_idle_release() -> None:
+    """A cancel that fails leaves the parked task to be released later."""
+    handler = _interrupting_handler(_InterruptingAgent(), 0.1)
+    task = await _send(handler, 'book a flight')
+    # Lets the first request's cleanup start the timer before it is cancelled.
+    await asyncio.sleep(0.05)
+    active_task = handler._active_task_registry._active_tasks[task.id]
+
+    with (
+        patch.object(
+            active_task, 'cancel', AsyncMock(side_effect=RuntimeError('boom'))
+        ),
+        pytest.raises(RuntimeError),
+    ):
+        await handler.on_cancel_task(
+            CancelTaskRequest(id=task.id), create_server_call_context()
+        )
+
+    assert await _wait_for_release(handler, task.id)
+    await handler.aclose()
+
+
+class SilentExecutor(AgentExecutor):
+    """Returns normally without producing any event (issue #1330)."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        return None
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+@pytest.mark.asyncio
+async def test_on_message_send_raises_when_agent_produces_no_events():
+    """A silent executor must fail fast instead of hanging forever (#1330)."""
+    request_handler = DefaultRequestHandlerV2(
+        agent_executor=SilentExecutor(),
+        task_store=InMemoryTaskStore(),
+        agent_card=create_default_agent_card(),
+    )
+    params = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER,
+            message_id='msg_silent',
+            parts=[Part(text='Hi')],
+        ),
+        configuration=SendMessageConfiguration(
+            accepted_output_modes=['text/plain']
+        ),
+    )
+
+    with pytest.raises(InvalidAgentResponseError, match='no events'):
+        await request_handler.on_message_send(
+            params, create_server_call_context()
+        )
diff --git a/tests/server/request_handlers/test_default_request_handler_v2_plugins.py b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py
new file mode 100644
index 000000000..fd0c6dbde
--- /dev/null
+++ b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py
@@ -0,0 +1,766 @@
+"""Plugin hooks run by DefaultRequestHandlerV2 (request, execution, task, push)."""
+
+import asyncio
+
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+import pytest
+
+from a2a import plugins
+from a2a.helpers.proto_helpers import new_task_from_user_message
+from a2a.plugins import (
+    CompletePlugin,
+    ExecutionPlugin,
+    PushPlugin,
+    PushRequest,
+    PushResult,
+    ServerRequest,
+    ServerResponse,
+    TaskEventInfo,
+    TaskObserverPlugin,
+)
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.agent_execution.plugin_agent_executor import (
+    PluginAgentExecutor,
+)
+from a2a.server.context import ServerCallContext
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import (
+    DefaultRequestHandlerV2,
+    LegacyRequestHandler,
+)
+from a2a.server.tasks import (
+    InMemoryPushNotificationConfigStore,
+    InMemoryTaskStore,
+    TaskUpdater,
+)
+from a2a.server.tasks.base_push_notification_sender import (
+    BasePushNotificationSender,
+)
+from a2a.types import TaskNotFoundError
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    CancelTaskRequest,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    SendMessageRequest,
+    SubscribeToTaskRequest,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+
+
+CARD = AgentCard(
+    name='plugin_test_agent',
+    version='1.0',
+    capabilities=AgentCapabilities(streaming=True, push_notifications=True),
+)
+
+
+class Recorder(CompletePlugin, ExecutionPlugin, TaskObserverPlugin, PushPlugin):
+    """Records (hook, argument) for every hook call."""
+
+    name = 'recorder'
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, Any]] = []
+
+    def hooks(self, name: str) -> list[Any]:
+        return [arg for hook, arg in self.calls if hook == name]
+
+    def names(self) -> list[str]:
+        return [hook for hook, _ in self.calls]
+
+    async def before_handler_run(self, request: ServerRequest) -> None:
+        self.calls.append(('before_handler_run', request))
+
+    async def after_handler_run(self, response: ServerResponse) -> None:
+        self.calls.append(('after_handler_run', response))
+
+    async def before_execution(self, request_context: RequestContext) -> None:
+        self.calls.append(('before_execution', request_context))
+
+    async def on_execution_event(self, request_context, event) -> None:
+        self.calls.append(('on_execution_event', event))
+
+    async def after_execution(self, request_context, error) -> None:
+        self.calls.append(('after_execution', error))
+
+    async def on_task_event(self, info: TaskEventInfo) -> None:
+        self.calls.append(('on_task_event', info))
+
+    async def before_push_send(self, request: PushRequest) -> None:
+        request.headers['x-plugin'] = 'yes'
+        self.calls.append(('before_push_send', request))
+
+    async def on_push_sent(self, result: PushResult) -> None:
+        self.calls.append(('on_push_sent', result))
+
+
+class TaskAgent(AgentExecutor):
+    """SUBMITTED -> WORKING -> artifact -> COMPLETED."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        task = context.current_task or new_task_from_user_message(
+            context.message
+        )
+        if not context.current_task:
+            await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.start_work()
+        await updater.add_artifact(parts=[Part(text='result')], name='out')
+        await updater.complete()
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+class MessageAgent(AgentExecutor):
+    """Replies with a single Message, creating no task."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue):
+        await event_queue.enqueue_event(
+            Message(
+                role=Role.ROLE_AGENT,
+                message_id='reply-1',
+                parts=[Part(text='hi')],
+            )
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        pass
+
+
+def send_request(
+    text: str = 'hello',
+    configuration: SendMessageConfiguration | None = None,
+) -> SendMessageRequest:
+    request = SendMessageRequest(
+        message=Message(
+            role=Role.ROLE_USER, message_id='m-1', parts=[Part(text=text)]
+        )
+    )
+    if configuration is not None:
+        request.configuration.CopyFrom(configuration)
+    return request
+
+
+async def wait_for(predicate: Callable[[], bool], timeout: float = 5) -> None:
+    async def poll() -> None:
+        while not predicate():
+            await asyncio.sleep(0.01)
+
+    await asyncio.wait_for(poll(), timeout)
+
+
+def make_handler(
+    recorder: Recorder | None,
+    executor: AgentExecutor | None = None,
+    **kwargs: Any,
+) -> DefaultRequestHandlerV2:
+    return DefaultRequestHandlerV2(
+        agent_executor=executor or TaskAgent(),
+        task_store=kwargs.pop('task_store', InMemoryTaskStore()),
+        agent_card=CARD,
+        plugins=plugins.sequential(recorder) if recorder else None,
+        **kwargs,
+    )
+
+
+@pytest.fixture(autouse=True)
+def restore_global():
+    previous = plugins.get_global()
+    yield
+    plugins.set_global(previous)
+
+
+def test_no_plugins_leaves_executor_unwrapped():
+    executor = TaskAgent()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=executor, task_store=InMemoryTaskStore(), agent_card=CARD
+    )
+
+    assert not handler.plugins.has_server_hooks
+    assert handler._active_task_registry._agent_executor is executor
+    assert handler.agent_card is CARD
+
+
+def test_global_manager_is_used_by_default():
+    recorder = Recorder()
+    manager = plugins.sequential(recorder)
+    plugins.set_global(manager)
+    executor = TaskAgent()
+
+    handler = DefaultRequestHandlerV2(
+        agent_executor=executor, task_store=InMemoryTaskStore(), agent_card=CARD
+    )
+
+    assert handler.plugins is manager
+    assert handler.agent_executor is executor
+    assert isinstance(
+        handler._active_task_registry._agent_executor, PluginAgentExecutor
+    )
+
+
+@pytest.mark.asyncio
+async def test_no_plugins_request_still_works():
+    handler = make_handler(None)
+    result = await handler.on_message_send(send_request(), ServerCallContext())
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_send_message_runs_all_server_hooks():
+    recorder = Recorder()
+    handler = make_handler(recorder)
+    context = ServerCallContext()
+
+    result = await handler.on_message_send(send_request(), context)
+    await wait_for(lambda: 'after_execution' in recorder.names())
+
+    assert isinstance(result, Task)
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+
+    (request,) = recorder.hooks('before_handler_run')
+    assert request.method == 'send_message'
+    assert request.context is context
+    assert request.agent_card is CARD
+    assert request.payload.message.message_id == 'm-1'
+
+    (response,) = recorder.hooks('after_handler_run')
+    assert response.method == 'send_message'
+    assert response.payload is result
+    assert response.error is None
+    assert response.is_final
+    assert not response.is_stream_event
+
+    # The execution runs with the same call context as the request.
+    (request_context,) = recorder.hooks('before_execution')
+    assert request_context.call_context is context
+    assert recorder.hooks('after_execution') == [None]
+
+    events = recorder.hooks('on_execution_event')
+    assert [type(e).__name__ for e in events] == [
+        'Task',
+        'TaskStatusUpdateEvent',
+        'TaskArtifactUpdateEvent',
+        'TaskStatusUpdateEvent',
+    ]
+
+    infos = recorder.hooks('on_task_event')
+    transitions = [(i.from_state, i.to_state) for i in infos]
+    assert transitions[0] == (None, TaskState.TASK_STATE_SUBMITTED)
+    assert (
+        TaskState.TASK_STATE_SUBMITTED,
+        TaskState.TASK_STATE_WORKING,
+    ) in transitions
+    assert (
+        TaskState.TASK_STATE_WORKING,
+        TaskState.TASK_STATE_WORKING,
+    ) in transitions
+    assert transitions[-1] == (
+        TaskState.TASK_STATE_WORKING,
+        TaskState.TASK_STATE_COMPLETED,
+    )
+    assert all(i.task_id == result.id for i in infos)
+    assert all(i.context is context for i in infos)
+
+    names = recorder.names()
+    assert names[0] == 'before_handler_run'
+    assert names.index('before_execution') < names.index('on_execution_event')
+
+
+@pytest.mark.asyncio
+async def test_streaming_reports_each_event_and_a_final_call():
+    recorder = Recorder()
+    handler = make_handler(recorder)
+
+    streamed = [
+        event
+        async for event in handler.on_message_send_stream(
+            send_request(), ServerCallContext()
+        )
+    ]
+
+    responses = recorder.hooks('after_handler_run')
+    assert [r.payload for r in responses[:-1]] == streamed
+    assert all(r.is_stream_event and not r.is_final for r in responses[:-1])
+    final = responses[-1]
+    assert final.method == 'send_message_streaming'
+    assert final.is_final
+    assert not final.is_stream_event
+    assert final.payload is None
+    assert final.error is None
+
+
+@pytest.mark.asyncio
+async def test_stream_closed_early_still_gets_final_call():
+    recorder = Recorder()
+    handler = make_handler(recorder)
+
+    stream = handler.on_message_send_stream(send_request(), ServerCallContext())
+    await anext(stream)
+    await stream.aclose()
+
+    final = recorder.hooks('after_handler_run')[-1]
+    assert final.is_final
+    assert final.error is None
+
+
+@pytest.mark.asyncio
+async def test_handler_error_reaches_after_handler_run():
+    recorder = Recorder()
+    handler = make_handler(recorder)
+
+    with pytest.raises(TaskNotFoundError):
+        await handler.on_get_task(
+            GetTaskRequest(id='missing'), ServerCallContext()
+        )
+
+    (response,) = recorder.hooks('after_handler_run')
+    assert response.method == 'get_task'
+    assert isinstance(response.error, TaskNotFoundError)
+    assert response.is_final
+
+
+@pytest.mark.asyncio
+async def test_stream_error_reaches_final_call():
+    recorder = Recorder()
+    handler = make_handler(recorder)
+
+    with pytest.raises(TaskNotFoundError):
+        async for _ in handler.on_message_send_stream(
+            SendMessageRequest(
+                message=Message(
+                    role=Role.ROLE_USER,
+                    message_id='m-2',
+                    task_id='missing',
+                    parts=[Part(text='x')],
+                )
+            ),
+            ServerCallContext(),
+        ):
+            pass
+
+    final = recorder.hooks('after_handler_run')[-1]
+    assert isinstance(final.error, TaskNotFoundError)
+
+
+class BlockingTaskStore(InMemoryTaskStore):
+    """Blocks every `get` until cancelled."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.waiting = asyncio.Event()
+
+    async def get(self, task_id, context):
+        self.waiting.set()
+        await asyncio.Event().wait()
+
+
+@pytest.mark.asyncio
+async def test_cancelled_call_reaches_after_handler_run():
+    recorder = Recorder()
+    store = BlockingTaskStore()
+    handler = make_handler(recorder, task_store=store)
+
+    call = asyncio.create_task(
+        handler.on_get_task(GetTaskRequest(id='t-1'), ServerCallContext())
+    )
+    await asyncio.wait_for(store.waiting.wait(), timeout=5)
+    call.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await call
+
+    (response,) = recorder.hooks('after_handler_run')
+    assert response.method == 'get_task'
+    assert isinstance(response.error, asyncio.CancelledError)
+    assert response.is_final
+
+
+@pytest.mark.asyncio
+async def test_cancelled_stream_reports_the_cancellation():
+    recorder = Recorder()
+    store = BlockingTaskStore()
+    handler = make_handler(recorder, task_store=store)
+
+    async def consume() -> None:
+        async for _ in handler.on_subscribe_to_task(
+            SubscribeToTaskRequest(id='t-1'), ServerCallContext()
+        ):
+            pass
+
+    reader = asyncio.create_task(consume())
+    await asyncio.wait_for(store.waiting.wait(), timeout=5)
+    reader.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await reader
+
+    (response,) = recorder.hooks('after_handler_run')
+    assert response.method == 'subscribe'
+    assert isinstance(response.error, asyncio.CancelledError)
+    assert response.is_final
+
+
+@pytest.mark.asyncio
+async def test_before_handler_run_can_reject_the_request():
+    class Deny(plugins.ServerPlugin):
+        async def before_handler_run(self, request):
+            raise PermissionError('denied')
+
+    executed = False
+
+    class Spy(TaskAgent):
+        async def execute(self, context, event_queue):
+            nonlocal executed
+            executed = True
+
+    handler = DefaultRequestHandlerV2(
+        agent_executor=Spy(),
+        task_store=InMemoryTaskStore(),
+        agent_card=CARD,
+        plugins=plugins.sequential(Deny()),
+    )
+
+    with pytest.raises(PermissionError):
+        await handler.on_message_send(send_request(), ServerCallContext())
+    with pytest.raises(PermissionError):
+        async for _ in handler.on_message_send_stream(
+            send_request(), ServerCallContext()
+        ):
+            pass
+    assert not executed
+
+
+@pytest.mark.asyncio
+async def test_message_only_agent_reports_event_but_no_task_write():
+    recorder = Recorder()
+    handler = make_handler(recorder, executor=MessageAgent())
+
+    result = await handler.on_message_send(send_request(), ServerCallContext())
+    await wait_for(lambda: 'after_execution' in recorder.names())
+
+    assert isinstance(result, Message)
+    (event,) = recorder.hooks('on_execution_event')
+    assert isinstance(event, Message)
+    assert recorder.hooks('on_task_event') == []
+
+
+@pytest.mark.asyncio
+async def test_before_execution_rejection_fails_the_task():
+    class Reject(plugins.ExecutionPlugin):
+        async def before_execution(self, request_context):
+            raise RuntimeError('not now')
+
+    recorder = Recorder()
+    handler = DefaultRequestHandlerV2(
+        agent_executor=TaskAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=CARD,
+        plugins=plugins.sequential(recorder, Reject()),
+    )
+
+    with pytest.raises(RuntimeError, match='not now'):
+        await handler.on_message_send(send_request(), ServerCallContext())
+
+    # The recorder ran before the rejecting plugin, so it is unwound.
+    assert recorder.hooks('on_execution_event') == []
+    (error,) = recorder.hooks('after_execution')
+    assert isinstance(error, RuntimeError)
+    failed = [
+        i
+        for i in recorder.hooks('on_task_event')
+        if i.to_state == TaskState.TASK_STATE_FAILED
+    ]
+    assert failed
+
+
+@pytest.mark.asyncio
+async def test_agent_error_reaches_after_execution():
+    class Boom(AgentExecutor):
+        async def execute(self, context, event_queue):
+            raise ValueError('boom')
+
+        async def cancel(self, context, event_queue):
+            pass
+
+    recorder = Recorder()
+    handler = make_handler(recorder, executor=Boom())
+
+    with pytest.raises(ValueError, match='boom'):
+        await handler.on_message_send(send_request(), ServerCallContext())
+
+    (error,) = recorder.hooks('after_execution')
+    assert isinstance(error, ValueError)
+
+
+@pytest.mark.asyncio
+async def test_return_immediately_ends_request_before_execution():
+    release = asyncio.Event()
+
+    class SlowAgent(TaskAgent):
+        async def execute(self, context, event_queue):
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+            await release.wait()
+            await TaskUpdater(event_queue, task.id, task.context_id).complete()
+
+    recorder = Recorder()
+    handler = make_handler(recorder, executor=SlowAgent())
+
+    result = await handler.on_message_send(
+        send_request(
+            configuration=SendMessageConfiguration(return_immediately=True)
+        ),
+        ServerCallContext(),
+    )
+
+    assert result.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert recorder.hooks('after_handler_run')[0].is_final
+    assert 'after_execution' not in recorder.names()
+
+    release.set()
+    # after_execution (producer) and the final task write (consumer) run in
+    # different tasks, so wait for both.
+    await wait_for(
+        lambda: (
+            'after_execution' in recorder.names()
+            and recorder.hooks('on_task_event')[-1].to_state
+            == TaskState.TASK_STATE_COMPLETED
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_remote_cancel_reports_task_event():
+    recorder = Recorder()
+    store = InMemoryTaskStore()
+    context = ServerCallContext()
+    await store.save(
+        Task(
+            id='t-remote',
+            context_id='c-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        ),
+        context,
+    )
+    handler = make_handler(recorder, task_store=store)
+
+    result = await handler.on_cancel_task(
+        CancelTaskRequest(id='t-remote'), context
+    )
+
+    assert result.status.state == TaskState.TASK_STATE_CANCELED
+    (info,) = recorder.hooks('on_task_event')
+    assert info.from_state == TaskState.TASK_STATE_WORKING
+    assert info.to_state == TaskState.TASK_STATE_CANCELED
+    assert info.event.status.state == TaskState.TASK_STATE_CANCELED
+
+
+def push_setup(
+    responses: dict[str, int],
+    manager: plugins.PluginManager | None = None,
+) -> tuple[
+    InMemoryPushNotificationConfigStore,
+    BasePushNotificationSender,
+    list[httpx.Request],
+]:
+    received: list[httpx.Request] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        received.append(request)
+        return httpx.Response(responses.get(str(request.url), 200))
+
+    config_store = InMemoryPushNotificationConfigStore()
+    sender = BasePushNotificationSender(
+        httpx.AsyncClient(transport=httpx.MockTransport(handle)),
+        config_store,
+        plugins=manager,
+    )
+    return config_store, sender, received
+
+
+def push_request(url: str) -> SendMessageRequest:
+    return send_request(
+        configuration=SendMessageConfiguration(
+            task_push_notification_config=TaskPushNotificationConfig(
+                url=url, token='tok'
+            )
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_push_hooks_run_for_v2_deliveries():
+    recorder = Recorder()
+    config_store, sender, received = push_setup(
+        {'http://hook/fail': 500}, plugins.sequential(recorder)
+    )
+    handler = make_handler(
+        recorder, push_config_store=config_store, push_sender=sender
+    )
+
+    await handler.on_message_send(
+        push_request('http://hook/ok'), ServerCallContext()
+    )
+    await wait_for(lambda: len(recorder.hooks('on_push_sent')) >= 3)
+
+    assert received
+    assert all(r.headers['x-plugin'] == 'yes' for r in received)
+    assert all(r.headers['x-a2a-notification-token'] == 'tok' for r in received)
+    results = recorder.hooks('on_push_sent')
+    assert all(r.status_code == 200 and r.error is None for r in results)
+    assert all(r.duration_s >= 0 for r in results)
+    assert all(r.request.url == 'http://hook/ok' for r in results)
+
+    recorder.calls.clear()
+    await handler.on_message_send(
+        push_request('http://hook/fail'), ServerCallContext()
+    )
+    await wait_for(lambda: len(recorder.hooks('on_push_sent')) >= 1)
+    failed = recorder.hooks('on_push_sent')[0]
+    assert failed.status_code == 500
+    assert isinstance(failed.error, httpx.HTTPStatusError)
+
+
+@pytest.mark.asyncio
+async def test_push_skip_and_rejection():
+    class SkipAll(PushPlugin):
+        async def before_push_send(self, request):
+            request.skip = True
+
+    class Fail(PushPlugin):
+        async def before_push_send(self, request):
+            raise RuntimeError('no')
+
+    seen: list[PushResult] = []
+
+    class Seen(PushPlugin):
+        async def on_push_sent(self, result):
+            seen.append(result)
+
+    for plugin, check in (
+        (SkipAll(), lambda r: r.skipped and r.error is None),
+        (Fail(), lambda r: isinstance(r.error, RuntimeError)),
+    ):
+        seen.clear()
+        config_store, sender, received = push_setup(
+            {}, plugins.sequential(plugin, Seen())
+        )
+        handler = DefaultRequestHandlerV2(
+            agent_executor=TaskAgent(),
+            task_store=InMemoryTaskStore(),
+            agent_card=CARD,
+            push_config_store=config_store,
+            push_sender=sender,
+        )
+        await handler.on_message_send(
+            push_request('http://hook/x'), ServerCallContext()
+        )
+        await wait_for(lambda: len(seen) >= 1)
+        assert received == []
+        assert all(check(r) for r in seen)
+
+
+@pytest.mark.asyncio
+async def test_push_url_validator_rejection_runs_no_hooks():
+    async def reject(url: str) -> bool:
+        return False
+
+    received: list[httpx.Request] = []
+    recorder = Recorder()
+    config_store = InMemoryPushNotificationConfigStore()
+    sender = BasePushNotificationSender(
+        httpx.AsyncClient(
+            transport=httpx.MockTransport(
+                lambda r: received.append(r) or httpx.Response(200)
+            )
+        ),
+        config_store,
+        push_url_validator=reject,
+        plugins=plugins.sequential(recorder),
+    )
+    handler = make_handler(
+        recorder, push_config_store=config_store, push_sender=sender
+    )
+
+    await handler.on_message_send(
+        push_request('http://hook/x'), ServerCallContext()
+    )
+    await wait_for(lambda: 'after_execution' in recorder.names())
+    await asyncio.sleep(0.05)
+
+    assert received == []
+    assert recorder.hooks('before_push_send') == []
+
+
+@pytest.mark.asyncio
+async def test_legacy_handler_runs_only_push_hooks():
+    """The legacy handler is not wired for plugins; the sender is on its own."""
+    recorder = Recorder()
+    plugins.set_global(plugins.sequential(recorder))
+    config_store, sender, received = push_setup({})
+    handler = LegacyRequestHandler(
+        agent_executor=TaskAgent(),
+        task_store=InMemoryTaskStore(),
+        agent_card=CARD,
+        push_config_store=config_store,
+        push_sender=sender,
+    )
+
+    result = await handler.on_message_send(
+        push_request('http://hook/legacy'), ServerCallContext()
+    )
+    await wait_for(lambda: bool(recorder.hooks('on_push_sent')))
+
+    assert result.status.state == TaskState.TASK_STATE_COMPLETED
+    assert received
+    assert all(r.headers['x-plugin'] == 'yes' for r in received)
+    assert set(recorder.names()) == {'before_push_send', 'on_push_sent'}
+
+
+def test_push_sender_uses_global_manager_unless_given_one():
+    manager = plugins.sequential(Recorder())
+    plugins.set_global(manager)
+    other = plugins.sequential()
+
+    default = BasePushNotificationSender(
+        httpx.AsyncClient(), InMemoryPushNotificationConfigStore()
+    )
+    explicit = BasePushNotificationSender(
+        httpx.AsyncClient(),
+        InMemoryPushNotificationConfigStore(),
+        plugins=other,
+    )
+
+    assert default._plugins is manager
+    assert explicit._plugins is other
+
+
+@pytest.mark.asyncio
+async def test_handler_plugins_do_not_reach_a_sender_with_its_own_manager():
+    recorder = Recorder()
+    config_store, sender, received = push_setup({})  # global: no plugins
+    handler = make_handler(
+        recorder, push_config_store=config_store, push_sender=sender
+    )
+
+    await handler.on_message_send(
+        push_request('http://hook/x'), ServerCallContext()
+    )
+    await wait_for(lambda: 'after_execution' in recorder.names())
+    await asyncio.sleep(0.05)
+
+    assert received
+    assert 'x-plugin' not in received[0].headers
+    assert recorder.hooks('before_push_send') == []
diff --git a/tests/server/request_handlers/test_grpc_handler.py b/tests/server/request_handlers/test_grpc_handler.py
new file mode 100644
index 000000000..fa504fc05
--- /dev/null
+++ b/tests/server/request_handlers/test_grpc_handler.py
@@ -0,0 +1,748 @@
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import grpc
+import grpc.aio
+import pytest
+
+from a2a import types
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers import GrpcHandler, RequestHandler
+from a2a.types import a2a_pb2
+from google.rpc import error_details_pb2, status_pb2
+
+
+# --- Fixtures ---
+
+
+@pytest.fixture
+def mock_request_handler() -> AsyncMock:
+    return AsyncMock(spec=RequestHandler)
+
+
+@pytest.fixture
+def mock_grpc_context() -> AsyncMock:
+    context = AsyncMock(spec=grpc.aio.ServicerContext)
+    context.abort = AsyncMock()
+    context.set_trailing_metadata = MagicMock()
+    return context
+
+
+@pytest.fixture
+def sample_agent_card() -> types.AgentCard:
+    return types.AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        supported_interfaces=[
+            types.AgentInterface(
+                protocol_binding='GRPC', url='http://localhost'
+            )
+        ],
+        version='1.0.0',
+        capabilities=types.AgentCapabilities(
+            streaming=True, push_notifications=True
+        ),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[],
+    )
+
+
+@pytest.fixture
+def grpc_handler(
+    mock_request_handler: AsyncMock, sample_agent_card: types.AgentCard
+) -> GrpcHandler:
+    mock_request_handler._agent_card = sample_agent_card
+    return GrpcHandler(request_handler=mock_request_handler)
+
+
+# --- Test Cases ---
+
+
+@pytest.mark.asyncio
+async def test_send_message_success(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test successful SendMessage call."""
+    request_proto = a2a_pb2.SendMessageRequest(
+        message=a2a_pb2.Message(message_id='msg-1')
+    )
+    response_model = types.Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=types.TaskStatus(state=types.TaskState.TASK_STATE_COMPLETED),
+    )
+    mock_request_handler.on_message_send.return_value = response_model
+
+    response = await grpc_handler.SendMessage(request_proto, mock_grpc_context)
+
+    mock_request_handler.on_message_send.assert_awaited_once()
+    assert isinstance(response, a2a_pb2.SendMessageResponse)
+    assert response.HasField('task')
+    assert response.task.id == 'task-1'
+
+
+@pytest.mark.asyncio
+async def test_send_message_server_error(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test SendMessage call when handler raises an A2AError."""
+    request_proto = a2a_pb2.SendMessageRequest()
+    error = types.InvalidParamsError(message='Bad params')
+    mock_request_handler.on_message_send.side_effect = error
+
+    await grpc_handler.SendMessage(request_proto, mock_grpc_context)
+
+    mock_grpc_context.abort.assert_awaited_once_with(
+        grpc.StatusCode.INVALID_ARGUMENT, 'Bad params'
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_task_success(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test successful GetTask call."""
+    request_proto = a2a_pb2.GetTaskRequest(id='task-1')
+    response_model = types.Task(
+        id='task-1',
+        context_id='ctx-1',
+        status=types.TaskStatus(state=types.TaskState.TASK_STATE_WORKING),
+    )
+    mock_request_handler.on_get_task.return_value = response_model
+
+    response = await grpc_handler.GetTask(request_proto, mock_grpc_context)
+
+    mock_request_handler.on_get_task.assert_awaited_once()
+    assert isinstance(response, a2a_pb2.Task)
+    assert response.id == 'task-1'
+
+
+@pytest.mark.asyncio
+async def test_get_task_not_found(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test GetTask call when task is not found."""
+    request_proto = a2a_pb2.GetTaskRequest(id='task-1')
+    mock_request_handler.on_get_task.return_value = None
+
+    await grpc_handler.GetTask(request_proto, mock_grpc_context)
+
+    mock_grpc_context.abort.assert_awaited_once_with(
+        grpc.StatusCode.NOT_FOUND, 'Task not found'
+    )
+
+
+@pytest.mark.asyncio
+async def test_send_streaming_message(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test successful SendStreamingMessage call."""
+
+    async def mock_stream():
+        yield types.Task(
+            id='task-1',
+            context_id='ctx-1',
+            status=types.TaskStatus(state=types.TaskState.TASK_STATE_WORKING),
+        )
+
+    # Use MagicMock because on_message_send_stream is an async generator,
+    # and we iterate over it directly. AsyncMock would return a coroutine.
+    mock_request_handler.on_message_send_stream = MagicMock(
+        return_value=mock_stream()
+    )
+    request_proto = a2a_pb2.SendMessageRequest()
+
+    results = [
+        result
+        async for result in grpc_handler.SendStreamingMessage(
+            request_proto, mock_grpc_context
+        )
+    ]
+
+    assert len(results) == 1
+    assert results[0].HasField('task')
+    assert results[0].task.id == 'task-1'
+
+
+@pytest.mark.asyncio
+async def test_get_extended_agent_card(
+    grpc_handler: GrpcHandler,
+    sample_agent_card: types.AgentCard,
+    mock_grpc_context: AsyncMock,
+    mock_request_handler: AsyncMock,
+) -> None:
+    """Test GetExtendedAgentCard call."""
+
+    async def to_coro(*args, **kwargs):
+        return sample_agent_card
+
+    mock_request_handler.on_get_extended_agent_card.side_effect = to_coro
+    request_proto = a2a_pb2.GetExtendedAgentCardRequest()
+    response = await grpc_handler.GetExtendedAgentCard(
+        request_proto, mock_grpc_context
+    )
+    mock_request_handler.on_get_extended_agent_card.assert_awaited_once()
+    assert response.name == sample_agent_card.name
+    assert response.version == sample_agent_card.version
+
+
+@pytest.mark.asyncio
+async def test_get_extended_agent_card_with_modifier(
+    mock_request_handler: AsyncMock,
+    sample_agent_card: types.AgentCard,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test GetExtendedAgentCard call with a card_modifier."""
+
+    async def modifier(card: types.AgentCard) -> types.AgentCard:
+        modified_card = types.AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Modified gRPC Agent'
+        return modified_card
+
+    # Use side_effect to ensure it returns an awaitable
+    async def side_effect_func(*_args, **_kwargs):
+        return await modifier(sample_agent_card)
+
+    mock_request_handler.on_get_extended_agent_card.side_effect = (
+        side_effect_func
+    )
+    mock_request_handler._agent_card = sample_agent_card
+    grpc_handler_modified = GrpcHandler(request_handler=mock_request_handler)
+    request_proto = a2a_pb2.GetExtendedAgentCardRequest()
+    response = await grpc_handler_modified.GetExtendedAgentCard(
+        request_proto, mock_grpc_context
+    )
+    mock_request_handler.on_get_extended_agent_card.assert_awaited_once()
+    assert response.name == 'Modified gRPC Agent'
+    assert response.version == sample_agent_card.version
+
+
+@pytest.mark.asyncio
+async def test_get_agent_card_with_modifier_sync(
+    mock_request_handler: AsyncMock,
+    sample_agent_card: types.AgentCard,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    """Test GetAgentCard call with a synchronous card_modifier."""
+
+    def modifier(card: types.AgentCard) -> types.AgentCard:
+        # For proto, we need to create a new message with modified fields
+        modified_card = types.AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Modified gRPC Agent'
+        return modified_card
+
+    async def async_modifier(*args, **kwargs):
+        return modifier(sample_agent_card)
+
+    mock_request_handler.on_get_extended_agent_card.side_effect = async_modifier
+    mock_request_handler._agent_card = sample_agent_card
+    grpc_handler_modified = GrpcHandler(request_handler=mock_request_handler)
+    request_proto = a2a_pb2.GetExtendedAgentCardRequest()
+    response = await grpc_handler_modified.GetExtendedAgentCard(
+        request_proto, mock_grpc_context
+    )
+    mock_request_handler.on_get_extended_agent_card.assert_awaited_once()
+    assert response.name == 'Modified gRPC Agent'
+    assert response.version == sample_agent_card.version
+
+
+@pytest.mark.asyncio
+async def test_list_tasks_success(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+):
+    """Test successful ListTasks call."""
+    mock_request_handler.on_list_tasks.return_value = a2a_pb2.ListTasksResponse(
+        next_page_token='123',
+        tasks=[
+            types.Task(
+                id='task-1',
+                context_id='ctx-1',
+                status=types.TaskStatus(
+                    state=types.TaskState.TASK_STATE_COMPLETED
+                ),
+            ),
+            types.Task(
+                id='task-2',
+                context_id='ctx-1',
+                status=types.TaskStatus(
+                    state=types.TaskState.TASK_STATE_WORKING
+                ),
+            ),
+        ],
+    )
+
+    response = await grpc_handler.ListTasks(
+        a2a_pb2.ListTasksRequest(page_size=2), mock_grpc_context
+    )
+
+    mock_request_handler.on_list_tasks.assert_awaited_once()
+    assert isinstance(response, a2a_pb2.ListTasksResponse)
+    assert len(response.tasks) == 2
+    assert response.tasks[0].id == 'task-1'
+    assert response.tasks[1].id == 'task-2'
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'a2a_error, grpc_status_code, error_message_part',
+    [
+        (
+            types.InvalidRequestError(),
+            grpc.StatusCode.INVALID_ARGUMENT,
+            'InvalidRequestError',
+        ),
+        (
+            types.MethodNotFoundError(),
+            grpc.StatusCode.NOT_FOUND,
+            'MethodNotFoundError',
+        ),
+        (
+            types.InvalidParamsError(),
+            grpc.StatusCode.INVALID_ARGUMENT,
+            'InvalidParamsError',
+        ),
+        (
+            types.InternalError(),
+            grpc.StatusCode.INTERNAL,
+            'InternalError',
+        ),
+        (
+            types.TaskNotFoundError(),
+            grpc.StatusCode.NOT_FOUND,
+            'TaskNotFoundError',
+        ),
+        (
+            types.TaskNotCancelableError(),
+            grpc.StatusCode.FAILED_PRECONDITION,
+            'TaskNotCancelableError',
+        ),
+        (
+            types.PushNotificationNotSupportedError(),
+            grpc.StatusCode.FAILED_PRECONDITION,
+            'PushNotificationNotSupportedError',
+        ),
+        (
+            types.UnsupportedOperationError(),
+            grpc.StatusCode.FAILED_PRECONDITION,
+            'UnsupportedOperationError',
+        ),
+        (
+            types.ContentTypeNotSupportedError(),
+            grpc.StatusCode.INVALID_ARGUMENT,
+            'ContentTypeNotSupportedError',
+        ),
+        (
+            types.InvalidAgentResponseError(),
+            grpc.StatusCode.INTERNAL,
+            'InvalidAgentResponseError',
+        ),
+    ],
+)
+async def test_abort_context_error_mapping(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+    a2a_error: Exception,
+    grpc_status_code: grpc.StatusCode,
+    error_message_part: str,
+) -> None:
+    mock_request_handler.on_get_task.side_effect = a2a_error
+    request_proto = a2a_pb2.GetTaskRequest(id='any')
+    await grpc_handler.GetTask(request_proto, mock_grpc_context)
+
+    mock_grpc_context.abort.assert_awaited_once()
+    call_args, _ = mock_grpc_context.abort.call_args
+    assert call_args[0] == grpc_status_code
+
+    # We shouldn't rely on the legacy ExceptionName: message string format
+    # But for backward compatability fallback it shouldn't fail
+    mock_grpc_context.set_trailing_metadata.assert_called_once()
+    metadata = mock_grpc_context.set_trailing_metadata.call_args[0][0]
+
+    assert any(key == 'grpc-status-details-bin' for key, _ in metadata)
+
+
+@pytest.mark.asyncio
+async def test_abort_context_rich_error_format(
+    grpc_handler: GrpcHandler,
+    mock_request_handler: AsyncMock,
+    mock_grpc_context: AsyncMock,
+) -> None:
+    error = types.TaskNotFoundError('Could not find the task')
+    mock_request_handler.on_get_task.side_effect = error
+    request_proto = a2a_pb2.GetTaskRequest(id='any')
+    await grpc_handler.GetTask(request_proto, mock_grpc_context)
+
+    mock_grpc_context.set_trailing_metadata.assert_called_once()
+    metadata = mock_grpc_context.set_trailing_metadata.call_args[0][0]
+
+    bin_values = [v for k, v in metadata if k == 'grpc-status-details-bin']
+    assert len(bin_values) == 1
+
+    status = status_pb2.Status.FromString(bin_values[0])
+    assert status.code == grpc.StatusCode.NOT_FOUND.value[0]
+    assert status.message == 'Could not find the task'
+
+    assert len(status.details) == 1
+
+    error_info = error_details_pb2.ErrorInfo()
+    status.details[0].Unpack(error_info)
+
+    assert error_info.reason == 'TASK_NOT_FOUND'
+    assert error_info.domain == 'a2a-protocol.org'
+
+
+@pytest.mark.asyncio
+class TestGrpcExtensions:
+    async def test_send_message_with_extensions(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+    ) -> None:
+        mock_grpc_context.invocation_metadata.return_value = grpc.aio.Metadata(
+            (HTTP_EXTENSION_HEADER.lower(), 'foo'),
+            (HTTP_EXTENSION_HEADER.lower(), 'bar'),
+        )
+        mock_request_handler.on_message_send.return_value = types.Task(
+            id='task-1',
+            context_id='ctx-1',
+            status=types.TaskStatus(state=types.TaskState.TASK_STATE_COMPLETED),
+        )
+
+        await grpc_handler.SendMessage(
+            a2a_pb2.SendMessageRequest(), mock_grpc_context
+        )
+
+        mock_request_handler.on_message_send.assert_awaited_once()
+        call_context = mock_request_handler.on_message_send.call_args[0][1]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.requested_extensions == {'foo', 'bar'}
+
+    async def test_send_message_with_comma_separated_extensions(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+    ) -> None:
+        mock_grpc_context.invocation_metadata.return_value = grpc.aio.Metadata(
+            (HTTP_EXTENSION_HEADER.lower(), 'foo ,, bar,'),
+            (HTTP_EXTENSION_HEADER.lower(), 'baz  , bar'),
+        )
+        mock_request_handler.on_message_send.return_value = types.Message(
+            message_id='1',
+            role=types.Role.ROLE_AGENT,
+            parts=[types.Part(text='test')],
+        )
+
+        await grpc_handler.SendMessage(
+            a2a_pb2.SendMessageRequest(), mock_grpc_context
+        )
+
+        mock_request_handler.on_message_send.assert_awaited_once()
+        call_context = mock_request_handler.on_message_send.call_args[0][1]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.requested_extensions == {'foo', 'bar', 'baz'}
+
+    async def test_send_streaming_message_with_extensions(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+    ) -> None:
+        mock_grpc_context.invocation_metadata.return_value = grpc.aio.Metadata(
+            (HTTP_EXTENSION_HEADER.lower(), 'foo'),
+            (HTTP_EXTENSION_HEADER.lower(), 'bar'),
+        )
+
+        async def side_effect(request, context: ServerCallContext):
+            yield types.Task(
+                id='task-1',
+                context_id='ctx-1',
+                status=types.TaskStatus(
+                    state=types.TaskState.TASK_STATE_WORKING
+                ),
+            )
+
+        mock_request_handler.on_message_send_stream.side_effect = side_effect
+
+        results = [
+            result
+            async for result in grpc_handler.SendStreamingMessage(
+                a2a_pb2.SendMessageRequest(), mock_grpc_context
+            )
+        ]
+        assert results
+
+        mock_request_handler.on_message_send_stream.assert_called_once()
+        call_context = mock_request_handler.on_message_send_stream.call_args[0][
+            1
+        ]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.requested_extensions == {'foo', 'bar'}
+
+
+@pytest.mark.asyncio
+class TestTenantExtraction:
+    @pytest.mark.parametrize(
+        'method_name, request_proto, handler_method_name, return_value',
+        [
+            (
+                'SendMessage',
+                a2a_pb2.SendMessageRequest(tenant='my-tenant'),
+                'on_message_send',
+                types.Message(),
+            ),
+            (
+                'CancelTask',
+                a2a_pb2.CancelTaskRequest(tenant='my-tenant', id='1'),
+                'on_cancel_task',
+                types.Task(id='1'),
+            ),
+            (
+                'GetTask',
+                a2a_pb2.GetTaskRequest(tenant='my-tenant', id='1'),
+                'on_get_task',
+                types.Task(id='1'),
+            ),
+            (
+                'ListTasks',
+                a2a_pb2.ListTasksRequest(tenant='my-tenant'),
+                'on_list_tasks',
+                a2a_pb2.ListTasksResponse(),
+            ),
+            (
+                'GetTaskPushNotificationConfig',
+                a2a_pb2.GetTaskPushNotificationConfigRequest(
+                    tenant='my-tenant', task_id='1', id='c1'
+                ),
+                'on_get_task_push_notification_config',
+                a2a_pb2.TaskPushNotificationConfig(),
+            ),
+            (
+                'CreateTaskPushNotificationConfig',
+                a2a_pb2.TaskPushNotificationConfig(
+                    tenant='my-tenant',
+                    task_id='1',
+                ),
+                'on_create_task_push_notification_config',
+                a2a_pb2.TaskPushNotificationConfig(),
+            ),
+            (
+                'ListTaskPushNotificationConfigs',
+                a2a_pb2.ListTaskPushNotificationConfigsRequest(
+                    tenant='my-tenant', task_id='1'
+                ),
+                'on_list_task_push_notification_configs',
+                a2a_pb2.ListTaskPushNotificationConfigsResponse(),
+            ),
+            (
+                'DeleteTaskPushNotificationConfig',
+                a2a_pb2.DeleteTaskPushNotificationConfigRequest(
+                    tenant='my-tenant', task_id='1', id='c1'
+                ),
+                'on_delete_task_push_notification_config',
+                None,
+            ),
+        ],
+    )
+    async def test_non_streaming_tenant_extraction(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+        method_name: str,
+        request_proto: Any,
+        handler_method_name: str,
+        return_value: Any,
+    ) -> None:
+        handler_mock = getattr(mock_request_handler, handler_method_name)
+        handler_mock.return_value = return_value
+
+        grpc_method = getattr(grpc_handler, method_name)
+        await grpc_method(request_proto, mock_grpc_context)
+
+        handler_mock.assert_awaited_once()
+        call_args = handler_mock.call_args
+        server_context = call_args[0][1]
+        assert isinstance(server_context, ServerCallContext)
+        assert server_context.tenant == 'my-tenant'
+
+    @pytest.mark.parametrize(
+        'method_name, request_proto, handler_method_name',
+        [
+            (
+                'SendStreamingMessage',
+                a2a_pb2.SendMessageRequest(tenant='my-tenant'),
+                'on_message_send_stream',
+            ),
+            (
+                'SubscribeToTask',
+                a2a_pb2.SubscribeToTaskRequest(tenant='my-tenant', id='1'),
+                'on_subscribe_to_task',
+            ),
+        ],
+    )
+    async def test_streaming_tenant_extraction(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+        method_name: str,
+        request_proto: Any,
+        handler_method_name: str,
+    ) -> None:
+        async def mock_stream(*args, **kwargs):
+            yield types.Message(message_id='msg-1')
+
+        handler_mock_attr = MagicMock(return_value=mock_stream())
+        setattr(mock_request_handler, handler_method_name, handler_mock_attr)
+
+        grpc_method = getattr(grpc_handler, method_name)
+
+        async for _ in grpc_method(request_proto, mock_grpc_context):
+            pass
+
+        handler_mock_attr.assert_called_once()
+        call_args = handler_mock_attr.call_args
+        server_context = call_args[0][1]
+        assert isinstance(server_context, ServerCallContext)
+        assert server_context.tenant == 'my-tenant'
+
+    @pytest.mark.parametrize(
+        'method_name, request_proto, handler_method_name, return_value',
+        [
+            (
+                'SendMessage',
+                a2a_pb2.SendMessageRequest(),
+                'on_message_send',
+                types.Message(),
+            ),
+            (
+                'CancelTask',
+                a2a_pb2.CancelTaskRequest(id='1'),
+                'on_cancel_task',
+                types.Task(id='1'),
+            ),
+            (
+                'GetTask',
+                a2a_pb2.GetTaskRequest(id='1'),
+                'on_get_task',
+                types.Task(id='1'),
+            ),
+            (
+                'ListTasks',
+                a2a_pb2.ListTasksRequest(),
+                'on_list_tasks',
+                a2a_pb2.ListTasksResponse(),
+            ),
+            (
+                'GetTaskPushNotificationConfig',
+                a2a_pb2.GetTaskPushNotificationConfigRequest(
+                    task_id='1', id='c1'
+                ),
+                'on_get_task_push_notification_config',
+                a2a_pb2.TaskPushNotificationConfig(),
+            ),
+            (
+                'CreateTaskPushNotificationConfig',
+                a2a_pb2.TaskPushNotificationConfig(
+                    task_id='1',
+                ),
+                'on_create_task_push_notification_config',
+                a2a_pb2.TaskPushNotificationConfig(),
+            ),
+            (
+                'ListTaskPushNotificationConfigs',
+                a2a_pb2.ListTaskPushNotificationConfigsRequest(task_id='1'),
+                'on_list_task_push_notification_configs',
+                a2a_pb2.ListTaskPushNotificationConfigsResponse(),
+            ),
+            (
+                'DeleteTaskPushNotificationConfig',
+                a2a_pb2.DeleteTaskPushNotificationConfigRequest(
+                    task_id='1', id='c1'
+                ),
+                'on_delete_task_push_notification_config',
+                None,
+            ),
+        ],
+    )
+    async def test_non_streaming_no_tenant_extraction(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+        method_name: str,
+        request_proto: Any,
+        handler_method_name: str,
+        return_value: Any,
+    ) -> None:
+        handler_mock = getattr(mock_request_handler, handler_method_name)
+        handler_mock.return_value = return_value
+
+        grpc_method = getattr(grpc_handler, method_name)
+        await grpc_method(request_proto, mock_grpc_context)
+
+        handler_mock.assert_awaited_once()
+        call_args = handler_mock.call_args
+        server_context = call_args[0][1]
+        assert isinstance(server_context, ServerCallContext)
+        assert server_context.tenant == ''
+
+    @pytest.mark.parametrize(
+        'method_name, request_proto, handler_method_name',
+        [
+            (
+                'SendStreamingMessage',
+                a2a_pb2.SendMessageRequest(),
+                'on_message_send_stream',
+            ),
+            (
+                'SubscribeToTask',
+                a2a_pb2.SubscribeToTaskRequest(id='1'),
+                'on_subscribe_to_task',
+            ),
+        ],
+    )
+    async def test_streaming_no_tenant_extraction(
+        self,
+        grpc_handler: GrpcHandler,
+        mock_request_handler: AsyncMock,
+        mock_grpc_context: AsyncMock,
+        method_name: str,
+        request_proto: Any,
+        handler_method_name: str,
+    ) -> None:
+        async def mock_stream(*args, **kwargs):
+            yield types.Message(message_id='msg-1')
+
+        handler_mock_attr = MagicMock(return_value=mock_stream())
+        setattr(mock_request_handler, handler_method_name, handler_mock_attr)
+
+        grpc_method = getattr(grpc_handler, method_name)
+
+        async for _ in grpc_method(request_proto, mock_grpc_context):
+            pass
+
+        handler_mock_attr.assert_called_once()
+        call_args = handler_mock_attr.call_args
+        server_context = call_args[0][1]
+        assert isinstance(server_context, ServerCallContext)
+        assert server_context.tenant == ''
diff --git a/tests/server/request_handlers/test_jsonrpc_handler.py b/tests/server/request_handlers/test_jsonrpc_handler.py
deleted file mode 100644
index c482fcf77..000000000
--- a/tests/server/request_handlers/test_jsonrpc_handler.py
+++ /dev/null
@@ -1,448 +0,0 @@
-import unittest
-import unittest.async_case
-from unittest.mock import AsyncMock, patch, MagicMock
-import pytest
-from a2a.server.events.event_queue import EventQueue
-from a2a.server.agent_execution import AgentExecutor
-from a2a.utils.errors import ServerError
-from a2a.server.request_handlers import (
-    DefaultRequestHandler,
-    JSONRPCHandler,
-)
-from a2a.server.events import (
-    QueueManager,
-)
-from a2a.server.tasks import TaskStore
-from a2a.types import (
-    AgentCard,
-    AgentCapabilities,
-    GetTaskRequest,
-    GetTaskResponse,
-    GetTaskSuccessResponse,
-    Task,
-    TaskQueryParams,
-    JSONRPCErrorResponse,
-    TaskNotFoundError,
-    TaskIdParams,
-    CancelTaskRequest,
-    CancelTaskSuccessResponse,
-    UnsupportedOperationError,
-    SendMessageRequest,
-    Message,
-    MessageSendParams,
-    SendMessageSuccessResponse,
-    SendStreamingMessageRequest,
-    SendStreamingMessageSuccessResponse,
-    TaskArtifactUpdateEvent,
-    TaskStatusUpdateEvent,
-    Artifact,
-    Part,
-    TextPart,
-    TaskStatus,
-    TaskState,
-    TaskResubscriptionRequest,
-)
-from collections.abc import AsyncGenerator
-from typing import Any
-
-MINIMAL_TASK: dict[str, Any] = {
-    'id': 'task_123',
-    'contextId': 'session-xyz',
-    'status': {'state': 'submitted'},
-    'type': 'task',
-}
-MESSAGE_PAYLOAD: dict[str, Any] = {
-    'role': 'agent',
-    'parts': [{'text': 'test message'}],
-    'messageId': '111',
-}
-
-
-class TestJSONRPCtHandler(unittest.async_case.IsolatedAsyncioTestCase):
-    @pytest.fixture(autouse=True)
-    def init_fixtures(self) -> None:
-        self.mock_agent_card = MagicMock(
-            spec=AgentCard, url='http://agent.example.com/api'
-        )
-
-    async def test_on_get_task_success(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        task_id = 'test_task_id'
-        mock_task = Task(**MINIMAL_TASK)
-        mock_task_store.get.return_value = mock_task
-        request = GetTaskRequest(id='1', params=TaskQueryParams(id=task_id))
-        response: GetTaskResponse = await handler.on_get_task(request)
-        self.assertIsInstance(response.root, GetTaskSuccessResponse)
-        assert response.root.result == mock_task  # type: ignore
-        mock_task_store.get.assert_called_once_with(task_id)
-
-    async def test_on_get_task_not_found(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task_store.get.return_value = None
-        request = GetTaskRequest(
-            id='1',
-            method='tasks/get',
-            params=TaskQueryParams(id='nonexistent_id'),
-        )
-        response: GetTaskResponse = await handler.on_get_task(request)
-        self.assertIsInstance(response.root, JSONRPCErrorResponse)
-        assert response.root.error == TaskNotFoundError()  # type: ignore
-
-    async def test_on_cancel_task_success(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        task_id = 'test_task_id'
-        mock_task = Task(**MINIMAL_TASK)
-        mock_task_store.get.return_value = mock_task
-        mock_agent_executor.cancel.return_value = None
-
-        async def streaming_coro():
-            yield mock_task
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            request = CancelTaskRequest(id='1', params=TaskIdParams(id=task_id))
-            response = await handler.on_cancel_task(request)
-            assert mock_agent_executor.cancel.call_count == 1
-            self.assertIsInstance(response.root, CancelTaskSuccessResponse)
-            assert response.root.result == mock_task  # type: ignore
-            mock_agent_executor.cancel.assert_called_once()
-
-    async def test_on_cancel_task_not_supported(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        task_id = 'test_task_id'
-        mock_task = Task(**MINIMAL_TASK)
-        mock_task_store.get.return_value = mock_task
-        mock_agent_executor.cancel.return_value = None
-
-        async def streaming_coro():
-            raise ServerError(UnsupportedOperationError())
-            yield
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            request = CancelTaskRequest(id='1', params=TaskIdParams(id=task_id))
-            response = await handler.on_cancel_task(request)
-            assert mock_agent_executor.cancel.call_count == 1
-            self.assertIsInstance(response.root, JSONRPCErrorResponse)
-            assert response.root.error == UnsupportedOperationError()  # type: ignore
-            mock_agent_executor.cancel.assert_called_once()
-
-    async def test_on_cancel_task_not_found(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task_store.get.return_value = None
-        request = CancelTaskRequest(
-            id='1',
-            method='tasks/cancel',
-            params=TaskIdParams(id='nonexistent_id'),
-        )
-        response = await handler.on_cancel_task(request)
-        self.assertIsInstance(response.root, JSONRPCErrorResponse)
-        assert response.root.error == TaskNotFoundError()  # type: ignore
-        mock_task_store.get.assert_called_once_with('nonexistent_id')
-        mock_agent_executor.cancel.assert_not_called()
-
-    async def test_on_message_new_message_success(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task = Task(**MINIMAL_TASK)
-        mock_task_store.get.return_value = mock_task
-        mock_agent_executor.execute.return_value = None
-
-        async def streaming_coro():
-            yield mock_task
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            request = SendMessageRequest(
-                id='1',
-                params=MessageSendParams(message=Message(**MESSAGE_PAYLOAD)),
-            )
-            response = await handler.on_message_send(request)
-            assert mock_agent_executor.execute.call_count == 1
-            self.assertIsInstance(response.root, SendMessageSuccessResponse)
-            assert response.root.result == mock_task  # type: ignore
-            mock_agent_executor.execute.assert_called_once()
-
-    async def test_on_message_new_message_with_existing_task_success(
-        self,
-    ) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task = Task(**MINIMAL_TASK)
-        mock_task_store.get.return_value = mock_task
-        mock_agent_executor.execute.return_value = None
-
-        async def streaming_coro():
-            yield mock_task
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            request = SendMessageRequest(
-                id='1',
-                params=MessageSendParams(
-                    message=Message(
-                        **MESSAGE_PAYLOAD,
-                        taskId=mock_task.id,
-                        contextId=mock_task.contextId,
-                    )
-                ),
-            )
-            response = await handler.on_message_send(request)
-            assert mock_agent_executor.execute.call_count == 1
-            self.assertIsInstance(response.root, SendMessageSuccessResponse)
-            assert response.root.result == mock_task  # type: ignore
-            mock_agent_executor.execute.assert_called_once()
-
-    async def test_on_message_error(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task_store.get.return_value = None
-        mock_agent_executor.execute.return_value = None
-
-        async def streaming_coro():
-            raise ServerError(error=UnsupportedOperationError())
-            yield
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            request = SendMessageRequest(
-                id='1',
-                params=MessageSendParams(
-                    message=Message(
-                        **MESSAGE_PAYLOAD,
-                    )
-                ),
-            )
-            response = await handler.on_message_send(request)
-
-            self.assertIsInstance(response.root, JSONRPCErrorResponse)
-            assert response.root.error == UnsupportedOperationError()  # type: ignore
-            mock_agent_executor.execute.assert_called_once()
-
-    async def test_on_message_stream_new_message_success(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        self.mock_agent_card.capabilities = AgentCapabilities(streaming=True)
-
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        events: list[Any] = [
-            Task(**MINIMAL_TASK),
-            TaskArtifactUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                artifact=Artifact(
-                    artifactId='11', parts=[Part(TextPart(text='text'))]
-                ),
-            ),
-            TaskStatusUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                status=TaskStatus(state=TaskState.completed),
-                final=True,
-            ),
-        ]
-
-        async def streaming_coro():
-            for event in events:
-                yield event
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            mock_task_store.get.return_value = None
-            mock_agent_executor.execute.return_value = None
-            request = SendStreamingMessageRequest(
-                id='1',
-                params=MessageSendParams(message=Message(**MESSAGE_PAYLOAD)),
-            )
-            response = handler.on_message_send_stream(request)
-            assert isinstance(response, AsyncGenerator)
-            collected_events: list[Any] = []
-            async for event in response:
-                collected_events.append(event)
-            assert len(collected_events) == len(events)
-            for i, event in enumerate(collected_events):
-                assert isinstance(
-                    event.root, SendStreamingMessageSuccessResponse
-                )
-                assert collected_events[i].root.result == events[i]
-            mock_agent_executor.execute.assert_called_once()
-
-    async def test_on_message_stream_new_message_existing_task_success(
-        self,
-    ) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-
-        self.mock_agent_card.capabilities = AgentCapabilities(streaming=True)
-
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task = Task(**MINIMAL_TASK, history=[])
-        events: list[Any] = [
-            mock_task,
-            TaskArtifactUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                artifact=Artifact(
-                    artifactId='11', parts=[Part(TextPart(text='text'))]
-                ),
-            ),
-            TaskStatusUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                status=TaskStatus(state=TaskState.working),
-                final=True,
-            ),
-        ]
-
-        async def streaming_coro():
-            for event in events:
-                yield event
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            mock_task_store.get.return_value = mock_task
-            mock_agent_executor.execute.return_value = None
-            request = SendStreamingMessageRequest(
-                id='1',
-                params=MessageSendParams(
-                    message=Message(
-                        **MESSAGE_PAYLOAD,
-                        taskId=mock_task.id,
-                        contextId=mock_task.contextId,
-                    )
-                ),
-            )
-            response = handler.on_message_send_stream(request)
-            assert isinstance(response, AsyncGenerator)
-            collected_events: list[Any] = []
-            async for event in response:
-                collected_events.append(event)
-            assert len(collected_events) == len(events)
-            mock_agent_executor.execute.assert_called_once()
-            assert mock_task.history is not None and len(mock_task.history) == 1
-
-    async def test_on_resubscribe_existing_task_success(
-        self,
-    ) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        mock_queue_manager = AsyncMock(spec=QueueManager)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store, mock_queue_manager
-        )
-        mock_agent_card = MagicMock(spec=AgentCard)
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task = Task(**MINIMAL_TASK, history=[])
-        events: list[Any] = [
-            TaskArtifactUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                artifact=Artifact(
-                    artifactId='11', parts=[Part(TextPart(text='text'))]
-                ),
-            ),
-            TaskStatusUpdateEvent(
-                taskId='task_123',
-                contextId='session-xyz',
-                status=TaskStatus(state=TaskState.completed),
-                final=True,
-            ),
-        ]
-
-        async def streaming_coro():
-            for event in events:
-                yield event
-
-        with patch(
-            'a2a.server.request_handlers.default_request_handler.EventConsumer.consume_all',
-            return_value=streaming_coro(),
-        ):
-            mock_task_store.get.return_value = mock_task
-            mock_queue_manager.tap.return_value = EventQueue()
-            request = TaskResubscriptionRequest(
-                id='1', params=TaskIdParams(id=mock_task.id)
-            )
-            response = handler.on_resubscribe_to_task(request)
-            assert isinstance(response, AsyncGenerator)
-            collected_events: list[Any] = []
-            async for event in response:
-                collected_events.append(event)
-            assert len(collected_events) == len(events)
-            assert mock_task.history is not None and len(mock_task.history) == 0
-
-    async def test_on_resubscribe_no_existing_task_error(self) -> None:
-        mock_agent_executor = AsyncMock(spec=AgentExecutor)
-        mock_task_store = AsyncMock(spec=TaskStore)
-        request_handler = DefaultRequestHandler(
-            mock_agent_executor, mock_task_store
-        )
-        handler = JSONRPCHandler(self.mock_agent_card, request_handler)
-        mock_task_store.get.return_value = None
-        request = TaskResubscriptionRequest(
-            id='1', params=TaskIdParams(id='nonexistent_id')
-        )
-        response = handler.on_resubscribe_to_task(request)
-        assert isinstance(response, AsyncGenerator)
-        collected_events: list[Any] = []
-        async for event in response:
-            collected_events.append(event)
-        assert len(collected_events) == 1
-        self.assertIsInstance(collected_events[0].root, JSONRPCErrorResponse)
-        assert collected_events[0].root.error == TaskNotFoundError()
diff --git a/tests/server/request_handlers/test_response_helpers.py b/tests/server/request_handlers/test_response_helpers.py
new file mode 100644
index 000000000..7236f2b61
--- /dev/null
+++ b/tests/server/request_handlers/test_response_helpers.py
@@ -0,0 +1,461 @@
+import logging
+import unittest
+
+from a2a.server.request_handlers.response_helpers import (
+    agent_card_to_dict,
+    build_error_response,
+    prepare_response_object,
+)
+from a2a.types import (
+    InvalidParamsError,
+    TaskNotFoundError,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+from google.protobuf.json_format import MessageToDict
+
+
+class TestResponseHelpers(unittest.TestCase):
+    def test_agent_card_to_dict_without_extended_card(self) -> None:
+        card = AgentCard(
+            name='Test Agent',
+            description='Test Description',
+            version='1.0',
+            capabilities=AgentCapabilities(extended_agent_card=False),
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://jsonrpc.v03.com',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3',
+                ),
+            ],
+        )
+        result = agent_card_to_dict(card)
+        self.assertNotIn('supportsAuthenticatedExtendedCard', result)
+        self.assertEqual(result['name'], 'Test Agent')
+
+    def test_agent_card_to_dict_with_extended_card(self) -> None:
+        card = AgentCard(
+            name='Test Agent',
+            description='Test Description',
+            version='1.0',
+            capabilities=AgentCapabilities(extended_agent_card=True),
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://jsonrpc.v03.com',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3',
+                ),
+            ],
+        )
+        result = agent_card_to_dict(card)
+        self.assertIn('supportsAuthenticatedExtendedCard', result)
+        self.assertTrue(result['supportsAuthenticatedExtendedCard'])
+        self.assertEqual(result['name'], 'Test Agent')
+
+    def test_agent_card_to_dict_all_transports_all_versions(self) -> None:
+        card = AgentCard(
+            name='Complex Agent',
+            description='Agent with many interfaces',
+            version='1.2.3',
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://jsonrpc.v10.com',
+                    protocol_binding='JSONRPC',
+                    protocol_version='1.0.0',
+                ),
+                AgentInterface(
+                    url='http://jsonrpc.v03.com',
+                    protocol_binding='JSONRPC',
+                    protocol_version='0.3.0',
+                ),
+                AgentInterface(
+                    url='http://grpc.v10.com',
+                    protocol_binding='GRPC',
+                    protocol_version='1.0.0',
+                ),
+                AgentInterface(
+                    url='http://grpc.v03.com',
+                    protocol_binding='GRPC',
+                    protocol_version='0.3.0',
+                ),
+                AgentInterface(
+                    url='http://httpjson.v10.com',
+                    protocol_binding='HTTP+JSON',
+                    protocol_version='1.0.0',
+                ),
+                AgentInterface(
+                    url='http://httpjson.v03.com',
+                    protocol_binding='HTTP+JSON',
+                    protocol_version='0.3.0',
+                ),
+            ],
+        )
+
+        result = agent_card_to_dict(card)
+
+        expected = {
+            'name': 'Complex Agent',
+            'description': 'Agent with many interfaces',
+            'version': '1.2.3',
+            'supportedInterfaces': [
+                {
+                    'url': 'http://jsonrpc.v10.com',
+                    'protocolBinding': 'JSONRPC',
+                    'protocolVersion': '1.0.0',
+                },
+                {
+                    'url': 'http://jsonrpc.v03.com',
+                    'protocolBinding': 'JSONRPC',
+                    'protocolVersion': '0.3.0',
+                },
+                {
+                    'url': 'http://grpc.v10.com',
+                    'protocolBinding': 'GRPC',
+                    'protocolVersion': '1.0.0',
+                },
+                {
+                    'url': 'http://grpc.v03.com',
+                    'protocolBinding': 'GRPC',
+                    'protocolVersion': '0.3.0',
+                },
+                {
+                    'url': 'http://httpjson.v10.com',
+                    'protocolBinding': 'HTTP+JSON',
+                    'protocolVersion': '1.0.0',
+                },
+                {
+                    'url': 'http://httpjson.v03.com',
+                    'protocolBinding': 'HTTP+JSON',
+                    'protocolVersion': '0.3.0',
+                },
+            ],
+            # Compatibility fields (v0.3)
+            'url': 'http://jsonrpc.v03.com',
+            'preferredTransport': 'JSONRPC',
+            'protocolVersion': '0.3.0',
+            'additionalInterfaces': [
+                {'url': 'http://grpc.v03.com', 'transport': 'GRPC'},
+                {'url': 'http://httpjson.v03.com', 'transport': 'HTTP+JSON'},
+            ],
+            'capabilities': {},
+            'defaultInputModes': [],
+            'defaultOutputModes': [],
+            'skills': [],
+        }
+
+        self.assertEqual(result, expected)
+
+    def test_agent_card_to_dict_only_1_0_interfaces(self) -> None:
+        card = AgentCard(
+            name='Modern Agent',
+            description='Agent with only 1.0 interfaces',
+            version='2.0.0',
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://jsonrpc.v10.com',
+                    protocol_binding='JSONRPC',
+                    protocol_version='1.0.0',
+                ),
+            ],
+        )
+
+        result = agent_card_to_dict(card)
+
+        expected = {
+            'name': 'Modern Agent',
+            'description': 'Agent with only 1.0 interfaces',
+            'version': '2.0.0',
+            'supportedInterfaces': [
+                {
+                    'url': 'http://jsonrpc.v10.com',
+                    'protocolBinding': 'JSONRPC',
+                    'protocolVersion': '1.0.0',
+                },
+            ],
+        }
+
+        self.assertEqual(result, expected)
+
+    def test_agent_card_to_dict_single_interface_no_version(self) -> None:
+        card = AgentCard(
+            name='Legacy Agent',
+            description='Agent with no protocol version',
+            version='1.0.0',
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://jsonrpc.legacy.com',
+                    protocol_binding='JSONRPC',
+                ),
+            ],
+        )
+
+        result = agent_card_to_dict(card)
+
+        expected = {
+            'name': 'Legacy Agent',
+            'description': 'Agent with no protocol version',
+            'version': '1.0.0',
+            'supportedInterfaces': [
+                {
+                    'url': 'http://jsonrpc.legacy.com',
+                    'protocolBinding': 'JSONRPC',
+                },
+            ],
+            # Compatibility fields (v0.3)
+            'url': 'http://jsonrpc.legacy.com',
+            'preferredTransport': 'JSONRPC',
+            'protocolVersion': '0.3',
+            'capabilities': {},
+            'defaultInputModes': [],
+            'defaultOutputModes': [],
+            'skills': [],
+        }
+
+        self.assertEqual(result, expected)
+
+    def test_build_error_response_with_a2a_error(self) -> None:
+        request_id = 'req1'
+        specific_error = TaskNotFoundError()
+        response = build_error_response(request_id, specific_error)
+
+        # Response is now a dict with JSON-RPC 2.0 structure
+        self.assertIsInstance(response, dict)
+        self.assertEqual(response.get('jsonrpc'), '2.0')
+        self.assertEqual(response.get('id'), request_id)
+        self.assertIn('error', response)
+        self.assertEqual(response['error']['code'], -32001)
+        self.assertEqual(response['error']['message'], specific_error.message)
+
+    def test_build_error_response_with_jsonrpc_error(self) -> None:
+        request_id = 123
+        json_rpc_error = InvalidParamsError(message='Custom invalid params')
+        response = build_error_response(request_id, json_rpc_error)
+
+        self.assertIsInstance(response, dict)
+        self.assertEqual(response.get('jsonrpc'), '2.0')
+        self.assertEqual(response.get('id'), request_id)
+        self.assertIn('error', response)
+        self.assertEqual(response['error']['code'], -32602)
+        self.assertEqual(response['error']['message'], json_rpc_error.message)
+
+    def test_build_error_response_with_invalid_params_error(self) -> None:
+        request_id = 'req_wrap'
+        specific_jsonrpc_error = InvalidParamsError(message='Detail error')
+        response = build_error_response(request_id, specific_jsonrpc_error)
+
+        self.assertIsInstance(response, dict)
+        self.assertEqual(response.get('jsonrpc'), '2.0')
+        self.assertEqual(response.get('id'), request_id)
+        self.assertIn('error', response)
+        self.assertEqual(response['error']['code'], -32602)
+        self.assertEqual(
+            response['error']['message'], specific_jsonrpc_error.message
+        )
+
+    def test_build_error_response_data_is_typed_details_array(self) -> None:
+        """error.data must be an array of typed-detail objects, with a
+        leading google.rpc.ErrorInfo carrying the canonical reason."""
+        error = TaskNotFoundError(data={'taskId': 'abc-123'})
+        response = build_error_response('req-typed', error)
+
+        data = response['error']['data']
+        self.assertIsInstance(data, list)
+        self.assertEqual(len(data), 1)
+        self.assertEqual(
+            data[0],
+            {
+                '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                'reason': 'TASK_NOT_FOUND',
+                'domain': 'a2a-protocol.org',
+                'metadata': {'taskId': 'abc-123'},
+            },
+        )
+
+    def test_build_error_response_invalid_params_appends_bad_request(
+        self,
+    ) -> None:
+        """InvalidParamsError carrying validation errors must append a
+        BadRequest typed-detail entry alongside ErrorInfo."""
+        error = InvalidParamsError(
+            message='Validation failed',
+            data={
+                'errors': [
+                    {
+                        'field': 'message.parts',
+                        'message': 'At least one required',
+                    },
+                    {'field': 'message.role', 'message': 'Unknown role'},
+                ]
+            },
+        )
+        response = build_error_response('req-bad', error)
+
+        data = response['error']['data']
+        self.assertEqual(len(data), 2)
+        error_info, bad_request = data
+        self.assertEqual(
+            error_info['@type'],
+            'type.googleapis.com/google.rpc.ErrorInfo',
+        )
+        self.assertEqual(error_info['reason'], 'INVALID_PARAMS')
+        self.assertEqual(
+            bad_request,
+            {
+                '@type': 'type.googleapis.com/google.rpc.BadRequest',
+                'fieldViolations': [
+                    {
+                        'field': 'message.parts',
+                        'description': 'At least one required',
+                    },
+                    {
+                        'field': 'message.role',
+                        'description': 'Unknown role',
+                    },
+                ],
+            },
+        )
+
+    def test_build_error_response_no_data_yields_empty_metadata(self) -> None:
+        """An A2AError with no data still produces a single
+        ErrorInfo entry with an empty metadata dict (per AIP-193)."""
+        error = TaskNotFoundError()
+        response = build_error_response('req-empty', error)
+        data = response['error']['data']
+        self.assertEqual(len(data), 1)
+        self.assertEqual(data[0]['metadata'], {})
+
+    def test_build_error_response_with_request_id_string(self) -> None:
+        request_id = 'string_id_test'
+        error = TaskNotFoundError()
+        response = build_error_response(request_id, error)
+
+        self.assertIsInstance(response, dict)
+        self.assertIn('error', response)
+        self.assertEqual(response.get('id'), request_id)
+
+    def test_build_error_response_with_request_id_int(self) -> None:
+        request_id = 456
+        error = TaskNotFoundError()
+        response = build_error_response(request_id, error)
+
+        self.assertIsInstance(response, dict)
+        self.assertIn('error', response)
+        self.assertEqual(response.get('id'), request_id)
+
+    def test_build_error_response_with_request_id_none(self) -> None:
+        request_id = None
+        error = TaskNotFoundError()
+        response = build_error_response(request_id, error)
+
+        self.assertIsInstance(response, dict)
+        self.assertIn('error', response)
+        self.assertIsNone(response.get('id'))
+
+    def _create_sample_task(
+        self, task_id: str = 'task123', context_id: str = 'ctx456'
+    ) -> Task:
+        return Task(
+            id=task_id,
+            context_id=context_id,
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+            history=[],
+        )
+
+    def test_prepare_response_object_with_proto_message(self) -> None:
+        request_id = 'req_success'
+        task_result = self._create_sample_task()
+        response = prepare_response_object(
+            request_id=request_id,
+            response=task_result,
+            success_response_types=(Task,),
+        )
+
+        # Response is now a dict with JSON-RPC 2.0 structure
+        self.assertIsInstance(response, dict)
+        self.assertEqual(response.get('jsonrpc'), '2.0')
+        self.assertEqual(response.get('id'), request_id)
+        self.assertIn('result', response)
+        # Result is the proto message converted to dict
+        expected_result = MessageToDict(
+            task_result, preserving_proto_field_name=False
+        )
+        self.assertEqual(response['result'], expected_result)
+
+    def test_prepare_response_object_with_error(self) -> None:
+        request_id = 'req_error'
+        error = TaskNotFoundError()
+        response = prepare_response_object(
+            request_id=request_id,
+            response=error,
+            success_response_types=(Task,),
+        )
+
+        self.assertIsInstance(response, dict)
+        self.assertEqual(response.get('jsonrpc'), '2.0')
+        self.assertEqual(response.get('id'), request_id)
+        self.assertIn('error', response)
+        self.assertEqual(response['error']['code'], -32001)
+
+    def test_prepare_response_object_with_invalid_response(self) -> None:
+        request_id = 'req_invalid'
+        invalid_response = object()
+        response = prepare_response_object(
+            request_id=request_id,
+            response=invalid_response,  # type: ignore
+            success_response_types=(Task,),
+        )
+
+        # Should return an InvalidAgentResponseError
+        self.assertIsInstance(response, dict)
+        self.assertIn('error', response)
+        # Check that it's an InvalidAgentResponseError (code -32006)
+        self.assertEqual(response['error']['code'], -32006)
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+
+class TestAgentCardToDictRequiredFields(unittest.TestCase):
+    def test_warns_when_required_fields_are_missing(self) -> None:
+        with self.assertLogs('a2a.utils.proto_utils', logging.WARNING) as logs:
+            result = agent_card_to_dict(AgentCard(name='partial'))
+        self.assertEqual(result['name'], 'partial')
+        [message] = logs.output
+        self.assertIn('agent_card passed to agent_card_to_dict:', message)
+        self.assertIn('description', message)
+
+    def test_complete_card_does_not_warn(self) -> None:
+        card = AgentCard(
+            name='complete_agent',
+            description='An agent card with all required fields.',
+            supported_interfaces=[
+                AgentInterface(
+                    url='http://localhost:8000',
+                    protocol_binding='JSONRPC',
+                    protocol_version='1.0',
+                )
+            ],
+            version='1.0',
+            capabilities=AgentCapabilities(),
+            default_input_modes=['text/plain'],
+            default_output_modes=['text/plain'],
+            skills=[
+                AgentSkill(
+                    id='echo',
+                    name='Echo',
+                    description='Echoes the input.',
+                    tags=['test'],
+                )
+            ],
+        )
+        with self.assertNoLogs('a2a.utils.proto_utils', logging.WARNING):
+            agent_card_to_dict(card)
diff --git a/tests/server/routes/__init__.py b/tests/server/routes/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/routes/test_agent_card_routes.py b/tests/server/routes/test_agent_card_routes.py
new file mode 100644
index 000000000..f3cb03ed6
--- /dev/null
+++ b/tests/server/routes/test_agent_card_routes.py
@@ -0,0 +1,289 @@
+import copy
+import logging
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a.server.routes.agent_card_routes import create_agent_card_routes
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+)
+from a2a.utils.signing import create_agent_card_signer
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from starlette.applications import Starlette
+from starlette.testclient import TestClient
+
+
+@pytest.fixture
+def agent_card():
+    return AgentCard()
+
+
+def test_get_agent_card_success(agent_card):
+    """Tests that the agent card route returns the card correctly."""
+    routes = create_agent_card_routes(agent_card=agent_card)
+
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    response = client.get('/.well-known/agent-card.json')
+    assert response.status_code == 200
+    assert response.headers['content-type'] == 'application/json'
+    assert response.json() == {}  # Empty card serializes to empty dict/json
+
+
+def test_get_agent_card_with_modifier(agent_card):
+    """Tests that card_modifier is called and modifies the response."""
+
+    # To test modification, let's assume we can mock the dict conversion or just see if the modifier runs.
+    # Actually card_modifier receives AgentCard and returns AgentCard.
+    async def modifier(card: AgentCard) -> AgentCard:
+        # Clone or modify
+        modified = AgentCard()
+        # Set some field if possible, or just return a different instance to verify.
+        # Since Protobuf objects have fields, let's look at one we can set.
+        # Usually they have fields like 'url' in v0.3 or others.
+        # Let's just return a MagicMock or set Something that shows up in dict if we know it.
+        # Wait, if we return a different object, we can verify it.
+        # Let's try to mock the conversion or just verify it was called.
+        return card
+
+    mock_modifier = AsyncMock(side_effect=modifier)
+    routes = create_agent_card_routes(
+        agent_card=agent_card, card_modifier=mock_modifier
+    )
+
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    response = client.get('/.well-known/agent-card.json')
+    assert response.status_code == 200
+    assert mock_modifier.called
+
+
+def test_agent_card_custom_url(agent_card):
+    """Tests that custom card_url is respected."""
+    custom_url = '/custom/path/agent.json'
+    routes = create_agent_card_routes(
+        agent_card=agent_card, card_url=custom_url
+    )
+
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    # Check that default returns 404
+    assert client.get('/.well-known/agent-card.json').status_code == 404
+    # Check that custom returns 200
+    assert client.get(custom_url).status_code == 200
+
+
+def card_client(**kwargs) -> TestClient:
+    return TestClient(
+        Starlette(routes=create_agent_card_routes(**kwargs)),
+        # Otherwise httpx resends the ETag it already saw and turns a
+        # deliberate unconditional GET into a 304.
+        headers={'cache-control': 'no-cache'},
+    )
+
+
+def test_response_carries_a_weak_etag():
+    response = card_client(agent_card=AgentCard(name='a', version='1')).get(
+        '/.well-known/agent-card.json'
+    )
+
+    assert response.status_code == 200
+    assert response.headers['etag'].startswith('W/"')
+
+
+def test_cache_control_is_sent_only_when_configured():
+    url = '/.well-known/agent-card.json'
+    card = AgentCard(name='a', version='1')
+
+    assert 'cache-control' not in card_client(agent_card=card).get(url).headers
+    configured = card_client(
+        agent_card=card, cache_control='public, max-age=3600'
+    ).get(url)
+    assert configured.headers['cache-control'] == 'public, max-age=3600'
+
+
+def test_etag_changes_with_the_card():
+    url = '/.well-known/agent-card.json'
+
+    first = card_client(agent_card=AgentCard(name='a', version='1')).get(url)
+    second = card_client(agent_card=AgentCard(name='b', version='1')).get(url)
+
+    assert first.headers['etag'] != second.headers['etag']
+
+
+def test_etag_tracks_the_modified_card_not_the_original():
+    """card_modifier can vary the body per request, so the hash must follow it."""
+    url = '/.well-known/agent-card.json'
+
+    async def rename(card: AgentCard) -> AgentCard:
+        return AgentCard(name='modified', version=card.version)
+
+    plain = card_client(agent_card=AgentCard(name='a', version='1')).get(url)
+    modified = card_client(
+        agent_card=AgentCard(name='a', version='1'), card_modifier=rename
+    ).get(url)
+
+    assert plain.headers['etag'] != modified.headers['etag']
+
+
+@pytest.mark.parametrize(
+    'make_header',
+    [
+        lambda etag: etag,
+        # Weak comparison, so the strong spelling of the same tag matches.
+        lambda etag: etag.removeprefix('W/'),
+        lambda etag: '*',
+        lambda etag: f'"other", {etag}',
+    ],
+    ids=['exact', 'strong-spelling', 'star', 'list'],
+)
+def test_matching_if_none_match_gets_304(make_header):
+    url = '/.well-known/agent-card.json'
+    client = card_client(agent_card=AgentCard(name='a', version='1'))
+    etag = client.get(url).headers['etag']
+
+    response = client.get(url, headers={'If-None-Match': make_header(etag)})
+
+    assert response.status_code == 304
+    assert response.content == b''
+
+
+def test_stale_if_none_match_gets_the_card():
+    url = '/.well-known/agent-card.json'
+    client = card_client(agent_card=AgentCard(name='a', version='1'))
+
+    response = client.get(url, headers={'If-None-Match': '"stale"'})
+
+    assert response.status_code == 200
+    assert response.json()['name'] == 'a'
+
+
+def test_a_card_re_signed_per_request_still_revalidates():
+    """The card_modifier that re-signs on every request must still get a 304.
+
+    ES256 signatures are randomized, so an unchanged card signs differently
+    every time. Hashing the signature in would produce a tag that changes on
+    every request and never once matches.
+    """
+    url = '/.well-known/agent-card.json'
+    private_key = ec.generate_private_key(ec.SECP256R1()).private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.PKCS8,
+        serialization.NoEncryption(),
+    )
+    sign = create_agent_card_signer(
+        signing_key=private_key,
+        protected_header={
+            'alg': 'ES256',
+            'kid': 'k',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+
+    async def sign_per_request(card: AgentCard) -> AgentCard:
+        return sign(copy.deepcopy(card))
+
+    client = card_client(
+        agent_card=AgentCard(name='a', version='1'),
+        card_modifier=sign_per_request,
+    )
+    first = client.get(url)
+    second = client.get(url)
+
+    # Same card, different signature, so the bodies differ byte for byte.
+    assert first.json()['signatures'] != second.json()['signatures']
+    assert first.headers['etag'] == second.headers['etag']
+    assert (
+        client.get(
+            url, headers={'If-None-Match': first.headers['etag']}
+        ).status_code
+        == 304
+    )
+
+
+def test_etag_still_changes_when_a_signed_card_changes():
+    """Excluding signatures must not blind the tag to real content changes."""
+    url = '/.well-known/agent-card.json'
+    sign = create_agent_card_signer(
+        signing_key='a-secret-long-enough-for-hs256-hmac',
+        protected_header={
+            'alg': 'HS256',
+            'kid': 'k',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+
+    def signed_client(name: str) -> TestClient:
+        async def modifier(card: AgentCard) -> AgentCard:
+            return sign(copy.deepcopy(card))
+
+        return card_client(
+            agent_card=AgentCard(name=name, version='1'),
+            card_modifier=modifier,
+        )
+
+    first = signed_client('a').get(url)
+    second = signed_client('b').get(url)
+
+    assert first.headers['etag'] != second.headers['etag']
+
+
+def _complete_agent_card() -> AgentCard:
+    """Returns an AgentCard with every field the A2A spec marks REQUIRED."""
+    return AgentCard(
+        name='complete_agent',
+        description='An agent card with all required fields.',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://localhost:8000',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            )
+        ],
+        version='1.0',
+        capabilities=AgentCapabilities(),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            AgentSkill(
+                id='echo',
+                name='Echo',
+                description='Echoes the input.',
+                tags=['test'],
+            )
+        ],
+    )
+
+
+def test_route_creation_warns_about_missing_required_fields(
+    agent_card: AgentCard, caplog: pytest.LogCaptureFixture
+) -> None:
+    """An incomplete card is still served, but a warning is logged once."""
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        routes = create_agent_card_routes(agent_card=agent_card)
+    [record] = caplog.records
+    message = record.getMessage()
+    assert 'agent_card passed to create_agent_card_routes:' in message
+    assert 'name, description, supported_interfaces' in message
+
+    client = TestClient(Starlette(routes=routes))
+    assert client.get('/.well-known/agent-card.json').status_code == 200
+
+
+def test_route_creation_does_not_warn_for_complete_card(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        create_agent_card_routes(agent_card=_complete_agent_card())
+    assert caplog.records == []
diff --git a/tests/server/routes/test_common.py b/tests/server/routes/test_common.py
new file mode 100644
index 000000000..9d285ca54
--- /dev/null
+++ b/tests/server/routes/test_common.py
@@ -0,0 +1,221 @@
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sse_starlette.sse import EventSourceResponse
+from starlette.datastructures import Headers
+
+
+try:
+    from starlette.authentication import BaseUser as StarletteBaseUser
+except ImportError:
+    StarletteBaseUser = MagicMock()  # type: ignore
+
+from a2a.auth.user import UnauthenticatedUser
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.server.context import ServerCallContext
+from a2a.server.routes.common import (
+    DefaultServerCallContextBuilder,
+    StarletteUser,
+    create_event_source_response,
+)
+
+
+class LegacyEventSourceResponse:
+    """Models a constructor without cooperative shutdown support."""
+
+    def __init__(self, content: Any) -> None:
+        self.content = content
+
+
+def test_default_grace_period_supports_legacy_sse_starlette() -> None:
+    content = []
+    with patch(
+        'a2a.server.routes.common.EventSourceResponse',
+        LegacyEventSourceResponse,
+    ):
+        response = create_event_source_response(content)
+
+    assert isinstance(response, LegacyEventSourceResponse)
+    assert response.content is content
+
+
+@pytest.mark.parametrize('grace_period', [0, 30.0])
+def test_grace_period_constructor_arguments(grace_period: float) -> None:
+    content = []
+    with patch.object(
+        EventSourceResponse, '__init__', autospec=True, return_value=None
+    ) as constructor:
+        response = create_event_source_response(content, grace_period)
+
+    if grace_period:
+        constructor.assert_called_once_with(
+            response, content, shutdown_grace_period=grace_period
+        )
+    else:
+        constructor.assert_called_once_with(response, content)
+
+
+def test_nonzero_grace_period_requires_cooperative_shutdown_support() -> None:
+    with (
+        patch(
+            'a2a.server.routes.common.EventSourceResponse',
+            LegacyEventSourceResponse,
+        ),
+        pytest.raises(
+            RuntimeError,
+            match=r'cooperative shutdown support.*a2a-sdk\[http-server\]',
+        ),
+    ):
+        create_event_source_response([], 30.0)
+
+
+@pytest.mark.parametrize(
+    'response_class', [LegacyEventSourceResponse, EventSourceResponse]
+)
+def test_negative_grace_period_is_rejected(response_class: type[Any]) -> None:
+    with (
+        patch('a2a.server.routes.common.EventSourceResponse', response_class),
+        pytest.raises(ValueError, match='shutdown_grace_period must be >= 0'),
+    ):
+        create_event_source_response([], -1)
+
+
+# --- StarletteUser Tests ---
+
+
+class TestStarletteUser:
+    def test_is_authenticated_true(self):
+        starlette_user = MagicMock(spec=StarletteBaseUser)
+        starlette_user.is_authenticated = True
+        proxy = StarletteUser(starlette_user)
+        assert proxy.is_authenticated is True
+
+    def test_is_authenticated_false(self):
+        starlette_user = MagicMock(spec=StarletteBaseUser)
+        starlette_user.is_authenticated = False
+        proxy = StarletteUser(starlette_user)
+        assert proxy.is_authenticated is False
+
+    def test_user_name(self):
+        starlette_user = MagicMock(spec=StarletteBaseUser)
+        starlette_user.display_name = 'Test User'
+        proxy = StarletteUser(starlette_user)
+        assert proxy.user_name == 'Test User'
+
+    def test_user_name_raises_attribute_error(self):
+        starlette_user = MagicMock(spec=StarletteBaseUser)
+        del starlette_user.display_name
+        proxy = StarletteUser(starlette_user)
+        with pytest.raises(AttributeError, match='display_name'):
+            _ = proxy.user_name
+
+
+# --- default_user_builder Tests ---
+
+
+def _make_mock_request(scope=None, headers=None):
+    request = MagicMock()
+    request.scope = scope or {}
+    request.headers = Headers(headers or {})
+    return request
+
+
+class TestDefaultContextBuilder:
+    def test_returns_unauthenticated_user_when_no_user_in_scope(self):
+        request = _make_mock_request(scope={})
+        user = DefaultServerCallContextBuilder().build_user(request)
+        assert isinstance(user, UnauthenticatedUser)
+        assert user.is_authenticated is False
+        assert user.user_name == ''
+
+    def test_returns_proxy_when_user_in_scope(self):
+        starlette_user = MagicMock()
+        starlette_user.is_authenticated = True
+        starlette_user.display_name = 'Alice'
+        request = _make_mock_request(scope={'user': starlette_user})
+        request.user = starlette_user
+
+        user = DefaultServerCallContextBuilder().build_user(request)
+        assert isinstance(user, StarletteUser)
+        assert user.is_authenticated is True
+        assert user.user_name == 'Alice'
+
+    def test_returns_unauthenticated_proxy_when_user_not_authenticated(self):
+        starlette_user = MagicMock()
+        starlette_user.is_authenticated = False
+        starlette_user.display_name = ''
+        request = _make_mock_request(scope={'user': starlette_user})
+        request.user = starlette_user
+
+        user = DefaultServerCallContextBuilder().build_user(request)
+        assert isinstance(user, StarletteUser)
+        assert user.is_authenticated is False
+
+
+# --- build_server_call_context Tests ---
+
+
+class TestBuildServerCallContext:
+    def test_basic_context_with_default_user_builder(self):
+        request = _make_mock_request(
+            scope={}, headers={'content-type': 'application/json'}
+        )
+        ctx = DefaultServerCallContextBuilder().build(request)
+
+        assert isinstance(ctx, ServerCallContext)
+        assert isinstance(ctx.user, UnauthenticatedUser)
+        assert 'headers' in ctx.state
+        assert ctx.state['headers']['content-type'] == 'application/json'
+        assert 'auth' not in ctx.state
+
+    def test_auth_populated_when_in_scope(self):
+        auth_credentials = MagicMock()
+        request = _make_mock_request(scope={'auth': auth_credentials})
+        request.auth = auth_credentials
+
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert ctx.state['auth'] is auth_credentials
+
+    def test_auth_not_populated_when_not_in_scope(self):
+        request = _make_mock_request(scope={})
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert 'auth' not in ctx.state
+
+    def test_headers_captured_in_state(self):
+        request = _make_mock_request(
+            headers={'x-custom': 'value', 'authorization': 'Bearer tok'}
+        )
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert ctx.state['headers']['x-custom'] == 'value'
+        assert ctx.state['headers']['authorization'] == 'Bearer tok'
+
+    def test_requested_extensions_single(self):
+        request = _make_mock_request(headers={HTTP_EXTENSION_HEADER: 'foo'})
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert ctx.requested_extensions == {'foo'}
+
+    def test_requested_extensions_comma_separated(self):
+        request = _make_mock_request(
+            headers={HTTP_EXTENSION_HEADER: 'foo, bar'}
+        )
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert ctx.requested_extensions == {'foo', 'bar'}
+
+    def test_no_extensions(self):
+        request = _make_mock_request()
+        ctx = DefaultServerCallContextBuilder().build(request)
+        assert ctx.requested_extensions == set()
+
+    def test_custom_user_builder(self):
+        custom_user = MagicMock(spec=UnauthenticatedUser)
+        custom_user.is_authenticated = True
+
+        class MyContextBuilder(DefaultServerCallContextBuilder):
+            def build_user(self, req):
+                return custom_user
+
+        request = _make_mock_request()
+        ctx = MyContextBuilder().build(request)
+        assert ctx.user is custom_user
diff --git a/tests/server/routes/test_fastapi_routes.py b/tests/server/routes/test_fastapi_routes.py
new file mode 100644
index 000000000..817862039
--- /dev/null
+++ b/tests/server/routes/test_fastapi_routes.py
@@ -0,0 +1,185 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import (
+    add_a2a_routes_to_fastapi,
+    create_agent_card_routes,
+    create_jsonrpc_routes,
+    create_rest_routes,
+)
+from a2a.server.routes.fastapi_routes import (
+    _AGENT_CARD_TAG,
+    _JSONRPC_TAG,
+    _REST_TAG,
+)
+from a2a.types.a2a_pb2 import AgentCard, Task
+from a2a.utils.constants import (
+    AGENT_CARD_WELL_KNOWN_PATH,
+    PROTOCOL_VERSION_1_0,
+    VERSION_HEADER,
+)
+
+
+fastapi = pytest.importorskip('fastapi')
+from fastapi import FastAPI  # noqa: E402
+from fastapi.testclient import TestClient  # noqa: E402
+
+
+@pytest.fixture
+def agent_card() -> AgentCard:
+    return AgentCard(name='Test Agent', version='1.0.0')
+
+
+@pytest.fixture
+def mock_handler() -> AsyncMock:
+    return AsyncMock(spec=RequestHandler)
+
+
+def _build_app(agent_card: AgentCard, mock_handler: AsyncMock) -> FastAPI:
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(
+        app,
+        agent_card_routes=create_agent_card_routes(agent_card),
+        jsonrpc_routes=create_jsonrpc_routes(mock_handler, rpc_url='/'),
+        rest_routes=create_rest_routes(mock_handler),
+    )
+    return app
+
+
+def test_routes_appear_in_openapi_with_tags(
+    agent_card: AgentCard, mock_handler: AsyncMock
+) -> None:
+    """Each group is documented and tagged for the Swagger UI."""
+    app = _build_app(agent_card, mock_handler)
+    paths = app.openapi()['paths']
+
+    assert paths[AGENT_CARD_WELL_KNOWN_PATH]['get']['tags'] == [_AGENT_CARD_TAG]
+    assert paths['/']['post']['tags'] == [_JSONRPC_TAG]
+    assert paths['/message:send']['post']['tags'] == [_REST_TAG]
+    assert paths['/tasks']['get']['tags'] == [_REST_TAG]
+
+
+def test_routes_dispatch_under_fastapi(
+    agent_card: AgentCard, mock_handler: AsyncMock
+) -> None:
+    """Re-registered routes still dispatch correctly under a FastAPI app."""
+    mock_handler.on_message_send.return_value = Task(id='task-123')
+
+    app = _build_app(agent_card, mock_handler)
+    client = TestClient(app)
+
+    assert client.get(AGENT_CARD_WELL_KNOWN_PATH).json()['name'] == 'Test Agent'
+    rpc_response = client.post(
+        '/', json={'jsonrpc': '2.0', 'id': '1', 'method': 'NoSuchMethod'}
+    ).json()
+    assert rpc_response['error']['code'] == -32601
+
+    rest_response = client.post(
+        '/message:send',
+        json={},
+        headers={VERSION_HEADER: PROTOCOL_VERSION_1_0},
+    )
+    assert rest_response.status_code == 200
+    assert rest_response.json()['task']['id'] == 'task-123'
+
+
+def test_tenant_mount_still_dispatches(mock_handler: AsyncMock) -> None:
+    """`Mount` entries (tenant routing) keep dispatching after registration."""
+    mock_handler.on_message_send.return_value = Task(id='tenant-task')
+
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(app, rest_routes=create_rest_routes(mock_handler))
+    client = TestClient(app)
+
+    response = client.post(
+        '/my-tenant/message:send',
+        json={},
+        headers={VERSION_HEADER: PROTOCOL_VERSION_1_0},
+    )
+    assert response.status_code == 200
+    context = mock_handler.on_message_send.call_args[0][1]
+    assert context.tenant == 'my-tenant'
+
+
+def test_partial_groups(agent_card: AgentCard, mock_handler: AsyncMock) -> None:
+    """Calling with only a subset of groups works and tags only those."""
+    app = FastAPI()
+    add_a2a_routes_to_fastapi(
+        app,
+        agent_card_routes=create_agent_card_routes(agent_card),
+    )
+    paths = app.openapi()['paths']
+    assert list(paths.keys()) == [AGENT_CARD_WELL_KNOWN_PATH]
+
+
+def test_request_body_schemas_are_attached(
+    agent_card: AgentCard, mock_handler: AsyncMock
+) -> None:
+    """JSON-RPC and REST POST bodies expose schemas derived from proto types."""
+    app = _build_app(agent_card, mock_handler)
+    schema = app.openapi()
+    components = schema['components']['schemas']
+
+    assert 'A2ARequest' in components
+    assert components['A2ARequest']['properties']['method']['enum']
+    rpc_body = schema['paths']['/']['post']['requestBody']
+    assert rpc_body['content']['application/json']['schema'] == {
+        '$ref': '#/components/schemas/A2ARequest'
+    }
+
+    send_body = schema['paths']['/message:send']['post']['requestBody']
+    assert send_body['required'] is True
+    assert send_body['content']['application/json']['schema'] == {
+        '$ref': '#/components/schemas/SendMessageRequest'
+    }
+
+    cancel_body = schema['paths']['/tasks/{id}:cancel']['post']['requestBody']
+    assert cancel_body['required'] is False
+    assert cancel_body['content']['application/json']['schema'] == {
+        '$ref': '#/components/schemas/CancelTaskRequest'
+    }
+
+    assert 'Message' in components
+    assert 'Part' in components
+    assert components['Message']['properties']['role']['enum'] == [
+        'ROLE_UNSPECIFIED',
+        'ROLE_USER',
+        'ROLE_AGENT',
+    ]
+
+
+def test_routes_without_body_have_no_request_body(
+    agent_card: AgentCard, mock_handler: AsyncMock
+) -> None:
+    """GET/DELETE/parameterless POST routes don't get a fabricated body."""
+    app = _build_app(agent_card, mock_handler)
+    paths = app.openapi()['paths']
+
+    assert 'requestBody' not in paths[AGENT_CARD_WELL_KNOWN_PATH]['get']
+    assert 'requestBody' not in paths['/tasks']['get']
+    assert 'requestBody' not in paths['/tasks/{id}:subscribe']['post']
+    assert (
+        'requestBody'
+        not in paths['/tasks/{id}/pushNotificationConfigs/{push_id}']['delete']
+    )
+
+
+def test_a2a_version_header_on_dispatcher_routes(
+    agent_card: AgentCard, mock_handler: AsyncMock
+) -> None:
+    """JSON-RPC and REST routes declare the version header so Swagger pre-fills it."""
+    app = _build_app(agent_card, mock_handler)
+    paths = app.openapi()['paths']
+
+    def _has_version_header(op: dict) -> bool:
+        return any(
+            p.get('name') == VERSION_HEADER for p in op.get('parameters', [])
+        )
+
+    assert _has_version_header(paths['/']['post'])
+    assert _has_version_header(paths['/message:send']['post'])
+    assert _has_version_header(paths['/tasks']['get'])
+    assert _has_version_header(paths['/tasks/{id}:cancel']['post'])
+    assert not _has_version_header(paths[AGENT_CARD_WELL_KNOWN_PATH]['get'])
diff --git a/tests/server/routes/test_jsonrpc_dispatcher.py b/tests/server/routes/test_jsonrpc_dispatcher.py
new file mode 100644
index 000000000..324d19327
--- /dev/null
+++ b/tests/server/routes/test_jsonrpc_dispatcher.py
@@ -0,0 +1,843 @@
+import asyncio
+
+from collections.abc import AsyncGenerator
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from starlette.responses import JSONResponse
+from starlette.testclient import TestClient
+
+
+try:
+    from starlette.authentication import BaseUser as StarletteBaseUser
+except ImportError:
+    StarletteBaseUser = MagicMock()  # type: ignore
+
+from a2a.extensions.common import HTTP_EXTENSION_HEADER
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import jsonrpc_dispatcher
+from a2a.server.routes.jsonrpc_dispatcher import JsonRpcDispatcher
+from a2a.server.routes.jsonrpc_routes import create_jsonrpc_routes
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    Artifact,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksResponse,
+    Message,
+    Part,
+    Role,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+
+
+# --- JsonRpcDispatcher Tests ---
+
+
+@pytest.fixture
+def mock_handler():
+    handler = AsyncMock(spec=RequestHandler)
+    handler.on_message_send.return_value = Message(
+        message_id='test',
+        role=Role.ROLE_AGENT,
+        parts=[Part(text='response message')],
+    )
+    return handler
+
+
+@pytest.fixture
+def test_app(mock_handler):
+    mock_agent_card = MagicMock(spec=AgentCard)
+    mock_agent_card.url = 'http://mockurl.com'
+    mock_agent_card.capabilities = MagicMock()
+    mock_agent_card.capabilities.streaming = False
+
+    jsonrpc_routes = create_jsonrpc_routes(
+        request_handler=mock_handler, rpc_url='/'
+    )
+
+    from starlette.applications import Starlette
+
+    return Starlette(routes=jsonrpc_routes)
+
+
+@pytest.fixture
+def client(test_app):
+    return TestClient(test_app, headers={'A2A-Version': '1.0'})
+
+
+def _make_send_message_request(
+    text: str = 'hi', tenant: str | None = None
+) -> dict:
+    params: dict[str, Any] = {
+        'message': {
+            'messageId': '1',
+            'role': 'ROLE_USER',
+            'parts': [{'text': text}],
+        }
+    }
+    if tenant is not None:
+        params['tenant'] = tenant
+
+    return {
+        'jsonrpc': '2.0',
+        'id': '1',
+        'method': 'SendMessage',
+        'params': params,
+    }
+
+
+class TestJsonRpcRequestIds:
+    """JSON booleans are not numeric JSON-RPC request identifiers."""
+
+    @pytest.mark.parametrize('request_id', [True, False])
+    def test_boolean_id_is_rejected(
+        self, client: TestClient, mock_handler: AsyncMock, request_id: bool
+    ) -> None:
+        request = _make_send_message_request()
+        request['id'] = request_id
+
+        response = client.post('/', json=request)
+        body = response.json()
+
+        assert response.status_code == 200
+        assert body['id'] is None
+        assert body['error']['code'] == -32600
+        mock_handler.on_message_send.assert_not_awaited()
+
+    @pytest.mark.parametrize('request_id', [0, 1, '', 'request'])
+    def test_integer_and_string_ids_are_preserved(
+        self, client: TestClient, mock_handler: AsyncMock, request_id: int | str
+    ) -> None:
+        request = _make_send_message_request()
+        request['id'] = request_id
+
+        response = client.post('/', json=request)
+        body = response.json()
+
+        assert response.status_code == 200
+        assert body['id'] == request_id
+        assert type(body['id']) is type(request_id)
+        assert 'result' in body
+        mock_handler.on_message_send.assert_awaited_once()
+
+
+class TestUnrecognizedFields:
+    """Unrecognized fields are ignored, for forward compatibility."""
+
+    def test_unknown_field_in_params_is_ignored(self, client):
+        request = _make_send_message_request()
+        request['params']['x_custom_field'] = 'test'
+
+        body = client.post('/', json=request).json()
+
+        assert 'error' not in body
+        assert 'result' in body
+
+    def test_unknown_field_inside_message_is_ignored(self, client):
+        request = _make_send_message_request()
+        request['params']['message']['x_custom_field'] = 'test'
+
+        body = client.post('/', json=request).json()
+
+        assert 'error' not in body
+        assert 'result' in body
+
+    def test_a_structurally_wrong_value_is_still_rejected(self, client):
+        """Leniency covers unknown names, not values of the wrong shape."""
+        request = _make_send_message_request()
+        request['params']['message']['parts'] = 'not-a-list'
+
+        body = client.post('/', json=request).json()
+
+        assert body['error']['code'] == -32602
+
+    def test_unknown_enum_value_is_accepted_as_unspecified(self, client):
+        """A documented side effect of ignore_unknown_fields, pinned here.
+
+        protobuf applies the same forward-compatibility rule to enum values
+        as to field names, and the flag cannot be taken for one and not the
+        other. A future ROLE_* therefore arrives as ROLE_UNSPECIFIED (0)
+        rather than failing the request.
+        """
+        request = _make_send_message_request()
+        request['params']['message']['role'] = 'ROLE_FROM_THE_FUTURE'
+
+        body = client.post('/', json=request).json()
+
+        assert 'error' not in body
+
+
+class TestParseErrorDataShape:
+    """error.data is an array of objects, each carrying @type."""
+
+    @pytest.fixture
+    def parse_error(self, client) -> dict:
+        request = _make_send_message_request()
+        request['params']['message']['parts'] = 'not-a-list'
+        return client.post('/', json=request).json()['error']
+
+    def test_data_is_a_typed_array(self, parse_error):
+        assert isinstance(parse_error['data'], list)
+        assert parse_error['data'][0]['@type'].endswith('google.rpc.ErrorInfo')
+        assert parse_error['data'][0]['reason'] == 'INVALID_PARAMS'
+
+    def test_parse_diagnostic_survives_in_metadata(self, parse_error):
+        assert 'parts' in parse_error['data'][0]['metadata']['parseError']
+
+
+class TestMalformedJsonBody:
+    def test_invalid_utf8_is_a_parse_error(self, client):
+        response = client.post(
+            '/',
+            content=b'{"jsonrpc": "2.0", "id": 1, "method": "GetTask", '
+            b'"params": {"id": "\xff"}}',
+            headers={'Content-Type': 'application/json'},
+        )
+
+        assert response.json()['error']['code'] == -32700
+
+    def test_reported_through_logging_not_stderr(self, client, capsys, caplog):
+        response = client.post(
+            '/',
+            content=b'{not json',
+            headers={'Content-Type': 'application/json'},
+        )
+
+        assert response.json()['error']['code'] == -32700
+        assert 'Traceback' not in capsys.readouterr().err
+        assert any(
+            record.name == jsonrpc_dispatcher.__name__
+            and record.levelname == 'WARNING'
+            for record in caplog.records
+        )
+
+
+class TestJsonRpcDispatcherOptionalDependencies:
+    @pytest.fixture(scope='class')
+    def mock_app_params(self) -> dict:
+        mock_handler = MagicMock(spec=RequestHandler)
+        mock_agent_card = MagicMock(spec=AgentCard)
+        mock_agent_card.url = 'http://example.com'
+        mock_handler._agent_card = mock_agent_card
+        return {'request_handler': mock_handler}
+
+    @pytest.fixture(scope='class')
+    def mark_pkg_starlette_not_installed(self):
+        pkg_starlette_installed_flag = (
+            jsonrpc_dispatcher._package_starlette_installed
+        )
+        jsonrpc_dispatcher._package_starlette_installed = False
+        yield
+        jsonrpc_dispatcher._package_starlette_installed = (
+            pkg_starlette_installed_flag
+        )
+
+    def test_create_dispatcher_with_missing_deps_raises_importerror(
+        self, mock_app_params: dict, mark_pkg_starlette_not_installed: Any
+    ):
+        with pytest.raises(
+            ImportError,
+            match=(
+                'Packages `starlette` and `sse-starlette` are required to use'
+                ' the `JsonRpcDispatcher`'
+            ),
+        ):
+            JsonRpcDispatcher(**mock_app_params)
+
+
+class TestJsonRpcDispatcherStreamingResponse:
+    def test_shutdown_grace_period_is_passed_to_event_source_response(
+        self, mock_handler
+    ) -> None:
+        async def stream_generator() -> AsyncGenerator[dict[str, Any]]:
+            yield {'result': {}}
+
+        dispatcher = JsonRpcDispatcher(
+            request_handler=mock_handler,
+            shutdown_grace_period=30.0,
+        )
+
+        response = dispatcher._create_response(
+            ServerCallContext(), stream_generator()
+        )
+
+        assert getattr(response, '_shutdown_grace_period') == 30.0
+
+
+class TestJsonRpcDispatcherExtensions:
+    def test_request_with_single_extension(self, client, mock_handler):
+        headers = {HTTP_EXTENSION_HEADER: 'foo'}
+        response = client.post(
+            '/',
+            headers=headers,
+            json=_make_send_message_request(),
+        )
+        response.raise_for_status()
+
+        mock_handler.on_message_send.assert_called_once()
+        call_context = mock_handler.on_message_send.call_args[0][1]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.requested_extensions == {'foo'}
+
+    def test_request_with_comma_separated_extensions(
+        self, client, mock_handler
+    ):
+        headers = {HTTP_EXTENSION_HEADER: 'foo, bar'}
+        response = client.post(
+            '/',
+            headers=headers,
+            json=_make_send_message_request(),
+        )
+        response.raise_for_status()
+
+        mock_handler.on_message_send.assert_called_once()
+        call_context = mock_handler.on_message_send.call_args[0][1]
+        assert call_context.requested_extensions == {'foo', 'bar'}
+
+    def test_method_added_to_call_context_state(self, client, mock_handler):
+        response = client.post(
+            '/',
+            json=_make_send_message_request(),
+        )
+        response.raise_for_status()
+
+        mock_handler.on_message_send.assert_called_once()
+        call_context = mock_handler.on_message_send.call_args[0][1]
+        assert call_context.state['method'] == 'SendMessage'
+
+
+class TestJsonRpcDispatcherTenant:
+    def test_tenant_extraction_from_params(self, client, mock_handler):
+        tenant_id = 'my-tenant-123'
+        response = client.post(
+            '/',
+            json=_make_send_message_request(tenant=tenant_id),
+        )
+        response.raise_for_status()
+
+        mock_handler.on_message_send.assert_called_once()
+        call_context = mock_handler.on_message_send.call_args[0][1]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.tenant == tenant_id
+
+    def test_no_tenant_extraction(self, client, mock_handler):
+        response = client.post(
+            '/',
+            json=_make_send_message_request(tenant=None),
+        )
+        response.raise_for_status()
+
+        mock_handler.on_message_send.assert_called_once()
+        call_context = mock_handler.on_message_send.call_args[0][1]
+        assert isinstance(call_context, ServerCallContext)
+        assert call_context.tenant == ''
+
+
+class TestJsonRpcDispatcherV03Compat:
+    def test_shutdown_grace_period_is_forwarded_to_adapter(
+        self, mock_handler
+    ) -> None:
+        with patch.object(
+            jsonrpc_dispatcher, 'JSONRPC03Adapter'
+        ) as adapter_class:
+            JsonRpcDispatcher(
+                request_handler=mock_handler,
+                enable_v0_3_compat=True,
+                shutdown_grace_period=30.0,
+            )
+
+        adapter_class.assert_called_once()
+        assert adapter_class.call_args.kwargs['http_handler'] is mock_handler
+        assert adapter_class.call_args.kwargs['shutdown_grace_period'] == 30.0
+
+    def test_v0_3_compat_flag_routes_to_adapter(self, mock_handler):
+        mock_agent_card = MagicMock(spec=AgentCard)
+        mock_agent_card.url = 'http://mockurl.com'
+        mock_agent_card.capabilities = MagicMock()
+        mock_agent_card.capabilities.streaming = False
+
+        mock_handler._agent_card = mock_agent_card
+
+        from starlette.applications import Starlette
+
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=mock_handler, enable_v0_3_compat=True, rpc_url='/'
+        )
+        app = Starlette(routes=jsonrpc_routes)
+        client = TestClient(app)
+
+        request_data = {
+            'jsonrpc': '2.0',
+            'id': '1',
+            'method': 'message/send',
+            'params': {
+                'message': {
+                    'messageId': 'msg-1',
+                    'role': 'ROLE_USER',
+                    'parts': [{'text': 'Hello'}],
+                }
+            },
+        }
+
+        dispatcher_instance = jsonrpc_routes[0].endpoint.__self__
+        with patch.object(
+            dispatcher_instance._v03_adapter,
+            'handle_request',
+            new_callable=AsyncMock,
+        ) as mock_handle:
+            mock_handle.return_value = JSONResponse(
+                {'jsonrpc': '2.0', 'id': '1', 'result': {}}
+            )
+
+            response = client.post('/', json=request_data)
+
+            response.raise_for_status()
+            assert mock_handle.called
+            assert mock_handle.call_args[1]['method'] == 'message/send'
+
+
+def _make_jsonrpc_request(method: str, params: dict | None = None) -> dict:
+    """Helper to build a JSON-RPC 2.0 request dict."""
+    return {
+        'jsonrpc': '2.0',
+        'id': '1',
+        'method': method,
+        'params': params or {},
+    }
+
+
+class TestJsonRpcDispatcherMethodRouting:
+    """Tests that each JSON-RPC method name routes to the correct handler."""
+
+    @pytest.fixture
+    def handler(self):
+        handler = AsyncMock(spec=RequestHandler)
+        handler.on_message_send.return_value = Message(
+            message_id='test',
+            role=Role.ROLE_AGENT,
+            parts=[Part(text='ok')],
+        )
+        handler.on_cancel_task.return_value = Task(
+            id='task1',
+            context_id='ctx1',
+            status=TaskStatus(state=TaskState.TASK_STATE_CANCELED),
+        )
+        handler.on_get_task.return_value = Task(
+            id='task1',
+            context_id='ctx1',
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+        )
+        handler.on_list_tasks.return_value = ListTasksResponse()
+        handler.on_create_task_push_notification_config.return_value = (
+            TaskPushNotificationConfig(task_id='t1', url='https://example.com')
+        )
+        handler.on_get_task_push_notification_config.return_value = (
+            TaskPushNotificationConfig(task_id='t1', url='https://example.com')
+        )
+        handler.on_list_task_push_notification_configs.return_value = (
+            ListTaskPushNotificationConfigsResponse()
+        )
+        handler.on_delete_task_push_notification_config.return_value = None
+        return handler
+
+    @pytest.fixture
+    def agent_card(self):
+        return AgentCard(
+            capabilities=AgentCapabilities(
+                streaming=True,
+                push_notifications=True,
+                extended_agent_card=True,
+            ),
+            name='TestAgent',
+            version='1.0',
+        )
+
+    @pytest.fixture
+    def client(self, handler, agent_card):
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=handler,
+            rpc_url='/',
+        )
+        from starlette.applications import Starlette
+
+        app = Starlette(routes=jsonrpc_routes)
+        return TestClient(app, headers={'A2A-Version': '1.0'})
+
+    # --- Non-streaming method routing tests ---
+
+    def test_send_message_routes_to_on_message_send(self, client, handler):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request(
+                'SendMessage',
+                {
+                    'message': {
+                        'messageId': '1',
+                        'role': 'ROLE_USER',
+                        'parts': [{'text': 'hello'}],
+                    }
+                },
+            ),
+        )
+        response.raise_for_status()
+
+        handler.on_message_send.assert_called_once()
+        call_context = handler.on_message_send.call_args[0][1]
+        assert call_context.state['method'] == 'SendMessage'
+
+    def test_cancel_task_routes_to_on_cancel_task(self, client, handler):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request('CancelTask', {'id': 'task1'}),
+        )
+        response.raise_for_status()
+
+        handler.on_cancel_task.assert_called_once()
+        call_context = handler.on_cancel_task.call_args[0][1]
+        assert call_context.state['method'] == 'CancelTask'
+
+    def test_get_task_routes_to_on_get_task(self, client, handler):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request('GetTask', {'id': 'task1'}),
+        )
+        response.raise_for_status()
+
+        handler.on_get_task.assert_called_once()
+        call_context = handler.on_get_task.call_args[0][1]
+        assert call_context.state['method'] == 'GetTask'
+
+    def test_list_tasks_routes_to_on_list_tasks(self, client, handler):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request('ListTasks'),
+        )
+        response.raise_for_status()
+
+        handler.on_list_tasks.assert_called_once()
+        call_context = handler.on_list_tasks.call_args[0][1]
+        assert call_context.state['method'] == 'ListTasks'
+
+    @pytest.mark.parametrize(
+        ('params', 'artifacts_expected'),
+        [
+            pytest.param({}, False, id='default'),
+            pytest.param({'includeArtifacts': True}, True, id='included'),
+        ],
+    )
+    def test_list_tasks_artifact_presence(
+        self,
+        client: TestClient,
+        handler: AsyncMock,
+        params: dict[str, Any],
+        artifacts_expected: bool,
+    ) -> None:
+        handler.on_list_tasks.return_value = ListTasksResponse(
+            tasks=[Task(id='task1')]
+        )
+
+        response = client.post(
+            '/', json=_make_jsonrpc_request('ListTasks', params)
+        )
+        response.raise_for_status()
+
+        task = response.json()['result']['tasks'][0]
+        assert ('artifacts' in task) is artifacts_expected
+
+    def test_create_push_notification_config_routes_correctly(
+        self, client, handler
+    ):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request(
+                'CreateTaskPushNotificationConfig',
+                {'taskId': 't1', 'url': 'https://example.com'},
+            ),
+        )
+        response.raise_for_status()
+
+        handler.on_create_task_push_notification_config.assert_called_once()
+        call_context = (
+            handler.on_create_task_push_notification_config.call_args[0][1]
+        )
+        assert (
+            call_context.state['method'] == 'CreateTaskPushNotificationConfig'
+        )
+
+    def test_get_push_notification_config_routes_correctly(
+        self, client, handler
+    ):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request(
+                'GetTaskPushNotificationConfig',
+                {'taskId': 't1', 'id': 'config1'},
+            ),
+        )
+        response.raise_for_status()
+
+        handler.on_get_task_push_notification_config.assert_called_once()
+        call_context = handler.on_get_task_push_notification_config.call_args[
+            0
+        ][1]
+        assert call_context.state['method'] == 'GetTaskPushNotificationConfig'
+
+    def test_list_push_notification_configs_routes_correctly(
+        self, client, handler
+    ):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request(
+                'ListTaskPushNotificationConfigs',
+                {'taskId': 't1'},
+            ),
+        )
+        response.raise_for_status()
+
+        handler.on_list_task_push_notification_configs.assert_called_once()
+        call_context = handler.on_list_task_push_notification_configs.call_args[
+            0
+        ][1]
+        assert call_context.state['method'] == 'ListTaskPushNotificationConfigs'
+
+    def test_delete_push_notification_config_routes_correctly(
+        self, client, handler
+    ):
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request(
+                'DeleteTaskPushNotificationConfig',
+                {'taskId': 't1', 'id': 'config1'},
+            ),
+        )
+        response.raise_for_status()
+        data = response.json()
+        assert data.get('result') is None
+
+        handler.on_delete_task_push_notification_config.assert_called_once()
+        call_context = (
+            handler.on_delete_task_push_notification_config.call_args[0][1]
+        )
+        assert (
+            call_context.state['method'] == 'DeleteTaskPushNotificationConfig'
+        )
+
+    def test_get_extended_agent_card_routes_correctly(
+        self, handler, agent_card
+    ):
+        captured: dict[str, Any] = {}
+
+        async def capture_modifier(card, context):
+            captured['method'] = context.state.get('method')
+            return card
+
+        handler.on_get_extended_agent_card.return_value = agent_card
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=handler,
+            rpc_url='/',
+        )
+        from starlette.applications import Starlette
+
+        app = Starlette(routes=jsonrpc_routes)
+        client = TestClient(app, headers={'A2A-Version': '1.0'})
+
+        response = client.post(
+            '/',
+            json=_make_jsonrpc_request('GetExtendedAgentCard'),
+        )
+        response.raise_for_status()
+        data = response.json()
+        assert 'result' in data
+        assert data['result']['name'] == 'TestAgent'
+        handler.on_get_extended_agent_card.assert_called_once()
+
+    # --- Streaming method routing tests ---
+
+    @pytest.mark.asyncio
+    async def test_send_streaming_message_routes_to_on_message_send_stream(
+        self, handler, agent_card
+    ):
+        async def stream_generator():
+            yield TaskArtifactUpdateEvent(
+                artifact=Artifact(
+                    artifact_id='a1',
+                    name='result',
+                    parts=[Part(text='streamed')],
+                ),
+                task_id='task1',
+                context_id='ctx1',
+                append=False,
+                last_chunk=True,
+            )
+
+        handler.on_message_send_stream = MagicMock(
+            return_value=stream_generator()
+        )
+
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=handler,
+            rpc_url='/',
+        )
+        from starlette.applications import Starlette
+
+        app = Starlette(routes=jsonrpc_routes)
+        client = TestClient(app, headers={'A2A-Version': '1.0'})
+
+        try:
+            with client.stream(
+                'POST',
+                '/',
+                json=_make_jsonrpc_request(
+                    'SendStreamingMessage',
+                    {
+                        'message': {
+                            'messageId': '1',
+                            'role': 'ROLE_USER',
+                            'parts': [{'text': 'hello'}],
+                        }
+                    },
+                ),
+            ) as response:
+                assert response.status_code == 200
+                assert response.headers['content-type'].startswith(
+                    'text/event-stream'
+                )
+                content = b''
+                for chunk in response.iter_bytes():
+                    content += chunk
+                assert b'a1' in content
+        finally:
+            client.close()
+            await asyncio.sleep(0.1)
+
+        handler.on_message_send_stream.assert_called_once()
+        call_context = handler.on_message_send_stream.call_args[0][1]
+        assert call_context.state['method'] == 'SendStreamingMessage'
+
+    @pytest.mark.asyncio
+    async def test_subscribe_to_task_routes_to_on_subscribe_to_task(
+        self, handler, agent_card
+    ):
+        async def stream_generator():
+            yield TaskArtifactUpdateEvent(
+                artifact=Artifact(
+                    artifact_id='a1',
+                    name='result',
+                    parts=[Part(text='streamed')],
+                ),
+                task_id='task1',
+                context_id='ctx1',
+                append=False,
+                last_chunk=True,
+            )
+
+        handler.on_subscribe_to_task = MagicMock(
+            return_value=stream_generator()
+        )
+
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=handler,
+            rpc_url='/',
+        )
+        from starlette.applications import Starlette
+
+        app = Starlette(routes=jsonrpc_routes)
+        client = TestClient(app, headers={'A2A-Version': '1.0'})
+
+        try:
+            with client.stream(
+                'POST',
+                '/',
+                json=_make_jsonrpc_request(
+                    'SubscribeToTask',
+                    {
+                        'id': 'task1',
+                    },
+                ),
+            ) as response:
+                assert response.status_code == 200
+                assert response.headers['content-type'].startswith(
+                    'text/event-stream'
+                )
+                content = b''
+                for chunk in response.iter_bytes():
+                    content += chunk
+                assert b'a1' in content
+        finally:
+            client.close()
+            await asyncio.sleep(0.1)
+
+        handler.on_subscribe_to_task.assert_called_once()
+        call_context = handler.on_subscribe_to_task.call_args[0][1]
+        assert call_context.state['method'] == 'SubscribeToTask'
+
+    @pytest.mark.asyncio
+    async def test_streaming_response_does_not_ascii_escape_non_ascii(
+        self, handler, agent_card
+    ):
+        """Non-ASCII characters (e.g. CJK) must be emitted as raw UTF-8."""
+        non_ascii_text = '你好'
+
+        async def stream_generator():
+            yield TaskArtifactUpdateEvent(
+                artifact=Artifact(
+                    artifact_id='a1',
+                    name='result',
+                    parts=[Part(text=non_ascii_text)],
+                ),
+                task_id='task1',
+                context_id='ctx1',
+                append=False,
+                last_chunk=True,
+            )
+
+        handler.on_message_send_stream = MagicMock(
+            return_value=stream_generator()
+        )
+
+        jsonrpc_routes = create_jsonrpc_routes(
+            request_handler=handler,
+            rpc_url='/',
+        )
+        from starlette.applications import Starlette
+
+        app = Starlette(routes=jsonrpc_routes)
+        client = TestClient(app, headers={'A2A-Version': '1.0'})
+
+        try:
+            with client.stream(
+                'POST',
+                '/',
+                json=_make_jsonrpc_request(
+                    'SendStreamingMessage',
+                    {
+                        'message': {
+                            'messageId': '1',
+                            'role': 'ROLE_USER',
+                            'parts': [{'text': non_ascii_text}],
+                        }
+                    },
+                ),
+            ) as response:
+                assert response.status_code == 200
+                content = b''
+                for chunk in response.iter_bytes():
+                    content += chunk
+        finally:
+            client.close()
+            await asyncio.sleep(0.1)
+
+        assert non_ascii_text.encode('utf-8') in content
+        assert b'\\u4f60\\u597d' not in content
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])
diff --git a/tests/server/routes/test_jsonrpc_routes.py b/tests/server/routes/test_jsonrpc_routes.py
new file mode 100644
index 000000000..4c25873a9
--- /dev/null
+++ b/tests/server/routes/test_jsonrpc_routes.py
@@ -0,0 +1,89 @@
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes.jsonrpc_routes import create_jsonrpc_routes
+from a2a.types.a2a_pb2 import AgentCard
+from starlette.applications import Starlette
+from starlette.testclient import TestClient
+
+
+@pytest.fixture
+def agent_card():
+    return AgentCard()
+
+
+@pytest.fixture
+def mock_handler():
+    return AsyncMock(spec=RequestHandler)
+
+
+def test_routes_creation(agent_card, mock_handler):
+    """Tests that create_jsonrpc_routes creates Route objects list."""
+    routes = create_jsonrpc_routes(
+        request_handler=mock_handler, rpc_url='/a2a/jsonrpc'
+    )
+
+    assert isinstance(routes, list)
+    assert len(routes) == 1
+
+    from starlette.routing import Route
+
+    assert isinstance(routes[0], Route)
+    assert routes[0].methods == {'POST'}
+
+
+def test_jsonrpc_custom_url(agent_card, mock_handler):
+    """Tests that custom rpc_url is respected for routing."""
+    custom_url = '/custom/api/jsonrpc'
+    routes = create_jsonrpc_routes(
+        request_handler=mock_handler, rpc_url=custom_url
+    )
+
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    # Check that default path returns 404
+    assert client.post('/a2a/jsonrpc', json={}).status_code == 404
+
+    # Check that custom path routes to dispatcher (which will return JSON-RPC response, even if error)
+    response = client.post(
+        custom_url, json={'jsonrpc': '2.0', 'id': '1', 'method': 'foo'}
+    )
+    assert response.status_code == 200
+    resp_json = response.json()
+    assert 'error' in resp_json
+    # Method not found error from dispatcher
+    assert resp_json['error']['code'] == -32601
+
+
+def test_shutdown_grace_period_is_forwarded_to_dispatcher(mock_handler) -> None:
+    """Tests that the route factory configures SSE cooperative shutdown."""
+    with patch(
+        'a2a.server.routes.jsonrpc_routes.JsonRpcDispatcher'
+    ) as dispatcher_class:
+        create_jsonrpc_routes(
+            request_handler=mock_handler,
+            rpc_url='/a2a/jsonrpc',
+        )
+        dispatcher_class.assert_called_once_with(
+            request_handler=mock_handler,
+            context_builder=None,
+            enable_v0_3_compat=False,
+            shutdown_grace_period=0,
+        )
+
+        dispatcher_class.reset_mock()
+        create_jsonrpc_routes(
+            request_handler=mock_handler,
+            rpc_url='/a2a/jsonrpc',
+            shutdown_grace_period=30.0,
+        )
+
+        dispatcher_class.assert_called_once_with(
+            request_handler=mock_handler,
+            context_builder=None,
+            enable_v0_3_compat=False,
+            shutdown_grace_period=30.0,
+        )
diff --git a/tests/server/routes/test_jsonrpc_schema.py b/tests/server/routes/test_jsonrpc_schema.py
new file mode 100644
index 000000000..d1c5f1d6d
--- /dev/null
+++ b/tests/server/routes/test_jsonrpc_schema.py
@@ -0,0 +1,71 @@
+from a2a.server.routes._jsonrpc_schema import (
+    DESCRIPTION,
+    METHOD_TYPES,
+    envelope_schema,
+)
+
+
+def test_envelope_schema_ref():
+    components = {}
+    ref = envelope_schema(components)
+    assert ref == {'$ref': '#/components/schemas/A2ARequest'}
+
+
+def test_envelope_schema_required_fields():
+    components = {}
+    envelope_schema(components)
+    assert components['A2ARequest']['required'] == ['jsonrpc', 'method']
+
+
+def test_envelope_schema_method_enum_matches_method_types():
+    components = {}
+    envelope_schema(components)
+    enum = components['A2ARequest']['properties']['method']['enum']
+    assert set(enum) == set(METHOD_TYPES)
+
+
+def test_envelope_schema_params_is_one_of():
+    components = {}
+    envelope_schema(components)
+    params = components['A2ARequest']['properties']['params']
+    assert 'oneOf' in params
+    assert len(params['oneOf']) > 0
+
+
+def test_envelope_schema_deduplicates_shared_param_types():
+    # SendMessage and SendStreamingMessage share SendMessageRequest.
+    components = {}
+    envelope_schema(components)
+    refs = [
+        r['$ref']
+        for r in components['A2ARequest']['properties']['params']['oneOf']
+    ]
+    assert len(refs) == len(set(refs))
+
+
+def test_envelope_schema_jsonrpc_version():
+    components = {}
+    envelope_schema(components)
+    assert components['A2ARequest']['properties']['jsonrpc']['enum'] == ['2.0']
+
+
+def test_method_types_contains_all_a2a_methods():
+    expected = {
+        'SendMessage',
+        'SendStreamingMessage',
+        'GetTask',
+        'ListTasks',
+        'CancelTask',
+        'CreateTaskPushNotificationConfig',
+        'GetTaskPushNotificationConfig',
+        'ListTaskPushNotificationConfigs',
+        'DeleteTaskPushNotificationConfig',
+        'SubscribeToTask',
+        'GetExtendedAgentCard',
+    }
+    assert set(METHOD_TYPES) == expected
+
+
+def test_description_lists_all_methods():
+    for method in METHOD_TYPES:
+        assert method in DESCRIPTION
diff --git a/tests/server/routes/test_proto_schema.py b/tests/server/routes/test_proto_schema.py
new file mode 100644
index 000000000..e11ea9c20
--- /dev/null
+++ b/tests/server/routes/test_proto_schema.py
@@ -0,0 +1,194 @@
+from a2a.server.routes._proto_schema import (
+    REST_BODY_TYPES,
+    field_schema,
+    message_schema,
+)
+from a2a.types.a2a_pb2 import Message, Part, SendMessageRequest
+
+
+def test_message_schema_registers_ref():
+    components = {}
+    ref = message_schema(SendMessageRequest.DESCRIPTOR, components)
+    assert ref == {'$ref': '#/components/schemas/SendMessageRequest'}
+    assert 'SendMessageRequest' in components
+
+
+def test_message_schema_returns_cached_ref():
+    components = {}
+    ref1 = message_schema(SendMessageRequest.DESCRIPTOR, components)
+    ref2 = message_schema(SendMessageRequest.DESCRIPTOR, components)
+    assert ref1 == ref2
+
+
+def test_message_schema_recurses_into_nested_types():
+    components = {}
+    message_schema(SendMessageRequest.DESCRIPTOR, components)
+    assert 'Message' in components
+    assert 'Part' in components
+
+
+def test_message_schema_well_known_type_inline():
+    from google.protobuf.descriptor_pool import Default
+
+    struct_descriptor = Default().FindMessageTypeByName(
+        'google.protobuf.Struct'
+    )
+    components = {}
+    schema = message_schema(struct_descriptor, components)
+    assert schema == {'type': 'object'}
+    assert 'Struct' not in components
+
+
+def test_message_schema_oneof_becomes_allof_with_one_of_constraint():
+    components = {}
+    message_schema(Part.DESCRIPTOR, components)
+    schema = components['Part']
+    assert 'allOf' in schema
+    one_of_constraint = next(p for p in schema['allOf'] if 'oneOf' in p)
+    oneof_keys = {list(v['properties'])[0] for v in one_of_constraint['oneOf']}
+    assert {'text', 'raw', 'url', 'data'} <= oneof_keys
+
+
+def test_message_schema_oneof_variants_have_required():
+    components = {}
+    message_schema(Part.DESCRIPTOR, components)
+    one_of_constraint = next(
+        p for p in components['Part']['allOf'] if 'oneOf' in p
+    )
+    for variant in one_of_constraint['oneOf']:
+        assert len(variant['required']) == 1
+
+
+def test_field_schema_repeated_wraps_in_array():
+    components = {}
+    msg_descriptor = SendMessageRequest.DESCRIPTOR.fields_by_name[
+        'message'
+    ].message_type
+    parts_field = msg_descriptor.fields_by_name['parts']
+    schema = field_schema(parts_field, components)
+    assert schema['type'] == 'array'
+    assert 'items' in schema
+
+
+def test_field_schema_enum():
+    role_field = Message.DESCRIPTOR.fields_by_name['role']
+    schema = field_schema(role_field, {})
+    assert schema['type'] == 'string'
+    assert 'ROLE_USER' in schema['enum']
+    assert 'ROLE_AGENT' in schema['enum']
+
+
+def test_field_schema_enum_example_skips_unspecified():
+    role_field = Message.DESCRIPTOR.fields_by_name['role']
+    schema = field_schema(role_field, {})
+    assert schema['example'] == 'ROLE_USER'
+
+
+def test_field_schema_string_example_is_empty():
+    context_id_field = Message.DESCRIPTOR.fields_by_name['context_id']
+    schema = field_schema(context_id_field, {})
+    assert schema['example'] == ''
+
+
+def test_field_schema_string_required_uses_field_name():
+    # REQUIRED string fields must be non-empty; the field name is the placeholder.
+    message_id_field = Message.DESCRIPTOR.fields_by_name['message_id']
+    schema = field_schema(message_id_field, {})
+    assert schema['example'] == 'message_id'
+
+
+def test_field_schema_bool_example_is_false():
+    from a2a.types.a2a_pb2 import SendMessageConfiguration
+
+    field = SendMessageConfiguration.DESCRIPTOR.fields_by_name[
+        'return_immediately'
+    ]
+    schema = field_schema(field, {})
+    assert schema['example'] is False
+
+
+def test_field_schema_optional_message_is_nullable():
+    # Non-REQUIRED message fields default to null so Swagger doesn't pre-fill them
+    # with empty sub-fields that trigger server-side required-field validation.
+    from a2a.types.a2a_pb2 import SendMessageConfiguration
+
+    field = SendMessageConfiguration.DESCRIPTOR.fields_by_name[
+        'task_push_notification_config'
+    ]
+    schema = field_schema(field, {})
+    assert schema['example'] is None
+    assert any(v == {'type': 'null'} for v in schema['oneOf'])
+
+
+def test_field_schema_required_message_is_not_nullable():
+    from a2a.types.a2a_pb2 import SendMessageRequest
+
+    field = SendMessageRequest.DESCRIPTOR.fields_by_name['message']
+    schema = field_schema(field, {})
+    assert '$ref' in schema
+    assert 'oneOf' not in schema
+
+
+def test_field_schema_repeated_optional_message_is_array_not_nullable():
+    # Repeated non-REQUIRED message fields must be wrapped as an array, not
+    # returned early as a nullable oneOf — the is_repeated check must come
+    # first. Task.history is a real repeated, non-required message field.
+    from a2a.types.a2a_pb2 import Task
+
+    field = Task.DESCRIPTOR.fields_by_name['history']
+    schema = field_schema(field, {})
+    assert schema['type'] == 'array'
+    assert 'oneOf' not in schema
+    assert '$ref' in schema['items']
+
+
+def test_message_schema_oneof_example_uses_first_variant_only():
+    components = {}
+    message_schema(Part.DESCRIPTOR, components)
+    example = components['Part']['example']
+    assert example == {'text': ''}
+    # base properties (metadata, filename, media_type) must not appear in the
+    # example — they are objects/strings that would be wrong if sent as "".
+    assert 'metadata' not in example
+    assert 'filename' not in example
+
+
+def test_field_schema_repeated_ref_example_propagated():
+    components = {}
+    msg_descriptor = SendMessageRequest.DESCRIPTOR.fields_by_name[
+        'message'
+    ].message_type
+    parts_field = msg_descriptor.fields_by_name['parts']
+    schema = field_schema(parts_field, components)
+    assert schema['type'] == 'array'
+    assert schema['example'] == [{'text': ''}]
+
+
+def test_field_schema_map_entry():
+    metadata_field = SendMessageRequest.DESCRIPTOR.fields_by_name['metadata']
+    schema = field_schema(metadata_field, {})
+    assert schema == {'type': 'object'}
+
+
+def test_rest_body_types_coverage() -> None:
+    assert ('/message:send', 'POST') in REST_BODY_TYPES
+    assert ('/message:stream', 'POST') in REST_BODY_TYPES
+    assert ('/tasks/{id}:cancel', 'POST') in REST_BODY_TYPES
+    assert ('/tasks/{id}/pushNotificationConfigs', 'POST') in REST_BODY_TYPES
+
+
+def test_full_schema_builds_for_all_rest_body_types():
+    # Safety net: build the complete schema for every registered REST body
+    # type into a shared components dict. Any proto field structure we don't
+    # support (or stop supporting after a proto change) fails right here
+    # rather than silently producing a broken Swagger document.
+    components: dict = {}
+    for msg in REST_BODY_TYPES.values():
+        ref = message_schema(msg.DESCRIPTOR, components)
+        assert ref['$ref'].startswith('#/components/schemas/')
+
+    # Every registered schema must be a non-empty object/composition (the
+    # cyclic-type placeholder is filled in before the build returns).
+    for name, schema in components.items():
+        assert schema, f'{name} resolved to an empty schema'
+        assert 'type' in schema or 'allOf' in schema or '$ref' in schema
diff --git a/tests/server/routes/test_rest_dispatcher.py b/tests/server/routes/test_rest_dispatcher.py
new file mode 100644
index 000000000..3d7bb3986
--- /dev/null
+++ b/tests/server/routes/test_rest_dispatcher.py
@@ -0,0 +1,486 @@
+import json
+
+from collections.abc import AsyncIterator
+from unittest.mock import AsyncMock, MagicMock
+
+import httpx
+import pytest
+
+from a2a.server.context import ServerCallContext
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes import rest_dispatcher
+from a2a.server.routes.rest_dispatcher import (
+    RestDispatcher,
+)
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    Artifact,
+    CancelTaskRequest,
+    ListTaskPushNotificationConfigsResponse,
+    ListTasksResponse,
+    Message,
+    Task,
+    TaskPushNotificationConfig,
+)
+from a2a.utils.errors import (
+    UnsupportedOperationError,
+)
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+
+@pytest.fixture
+def agent_card():
+    card = MagicMock(spec=AgentCard)
+    card.capabilities = AgentCapabilities(
+        streaming=True,
+        push_notifications=True,
+        extended_agent_card=True,
+    )
+    return card
+
+
+@pytest.fixture
+def mock_handler(agent_card):
+    handler = AsyncMock(spec=RequestHandler)
+    # Default success cases
+    handler._agent_card = agent_card
+    handler.on_message_send.return_value = Message(message_id='test_msg')
+    handler.on_cancel_task.return_value = Task(id='test_task')
+    handler.on_get_task.return_value = Task(id='test_task')
+    handler.on_get_extended_agent_card.return_value = agent_card()
+    handler.on_list_tasks.return_value = ListTasksResponse()
+    handler.on_get_task_push_notification_config.return_value = (
+        TaskPushNotificationConfig(url='http://test')
+    )
+    handler.on_create_task_push_notification_config.return_value = (
+        TaskPushNotificationConfig(url='http://test')
+    )
+    handler.on_list_task_push_notification_configs.return_value = (
+        ListTaskPushNotificationConfigsResponse()
+    )
+
+    # Streaming mocks
+    async def mock_stream(*args, **kwargs) -> AsyncIterator[Task]:
+        yield Task(id='chunk1')
+        yield Task(id='chunk2')
+
+    handler.on_message_send_stream.side_effect = mock_stream
+    handler.on_subscribe_to_task.side_effect = mock_stream
+    return handler
+
+
+@pytest.fixture
+def rest_dispatcher_instance(mock_handler):
+    return RestDispatcher(request_handler=mock_handler)
+
+
+from starlette.datastructures import Headers, QueryParams
+
+
+def make_mock_request(
+    method: str = 'GET',
+    path_params: dict | None = None,
+    query_params: dict | None = None,
+    headers: dict | None = None,
+    body: bytes = b'{}',
+) -> Request:
+    mock_req = MagicMock(spec=Request)
+    mock_req.method = method
+    mock_req.path_params = path_params or {}
+    mock_req.query_params = query_params or {}
+
+    # Default valid headers for A2A
+    default_headers = {'a2a-version': '1.0'}
+    if headers:
+        default_headers.update(headers)
+
+    mock_req.headers = Headers(default_headers)
+    mock_req.body = AsyncMock(return_value=body)
+
+    # Needs to be able to build ServerCallContext, so provide .user and .auth etc. if needed
+    mock_req.user = MagicMock(is_authenticated=False)
+    mock_req.auth = None
+    mock_req.scope = {}
+    return mock_req
+
+
+class TestRestDispatcherInitialization:
+    @pytest.fixture(scope='class')
+    def mark_pkg_starlette_not_installed(self):
+        pkg_starlette_installed_flag = (
+            rest_dispatcher._package_starlette_installed
+        )
+        rest_dispatcher._package_starlette_installed = False
+        yield
+        rest_dispatcher._package_starlette_installed = (
+            pkg_starlette_installed_flag
+        )
+
+    def test_missing_starlette_raises_importerror(
+        self, mark_pkg_starlette_not_installed, mock_handler
+    ):
+        with pytest.raises(
+            ImportError,
+            match='Packages `starlette` and `sse-starlette` are required',
+        ):
+            RestDispatcher(request_handler=mock_handler)
+
+
+@pytest.mark.asyncio
+class TestRestDispatcherContextManagement:
+    async def test_build_call_context(self, rest_dispatcher_instance):
+        req = make_mock_request(path_params={'tenant': 'my-tenant'})
+        context = rest_dispatcher_instance._build_call_context(req)
+
+        assert isinstance(context, ServerCallContext)
+        assert context.tenant == 'my-tenant'
+        assert context.state['headers']['a2a-version'] == '1.0'
+
+
+@pytest.mark.asyncio
+class TestRestDispatcherEndpoints:
+    async def test_on_message_send_throws_error_for_unsupported_version(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        # 0.3 is currently not supported for direct message sending on RestDispatcher
+        req = make_mock_request(method='POST', headers={'a2a-version': '0.3.0'})
+        response = await rest_dispatcher_instance.on_message_send(req)
+
+        # VersionNotSupportedError maps to 400 Bad Request
+        assert response.status_code == 400
+
+    async def test_on_message_send_returns_message(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        req = make_mock_request(method='POST')
+        response = await rest_dispatcher_instance.on_message_send(req)
+
+        assert isinstance(response, JSONResponse)
+        assert response.status_code == 200
+        data = json.loads(response.body)
+        assert 'message' in data
+
+    async def test_on_message_send_returns_task(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        mock_handler.on_message_send.return_value = Task(id='new_task')
+        req = make_mock_request(method='POST')
+
+        response = await rest_dispatcher_instance.on_message_send(req)
+        assert response.status_code == 200
+        data = json.loads(response.body)
+        assert 'task' in data
+        assert data['task']['id'] == 'new_task'
+
+    async def test_on_cancel_task_success(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        req = make_mock_request(method='POST', path_params={'id': 'test_task'})
+        response = await rest_dispatcher_instance.on_cancel_task(req)
+
+        assert response.status_code == 200
+        data = json.loads(response.body)
+        assert data['id'] == 'test_task'
+
+    async def test_on_cancel_task_not_found(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        mock_handler.on_cancel_task.return_value = None
+        req = make_mock_request(method='POST', path_params={'id': 'test_task'})
+
+        response = await rest_dispatcher_instance.on_cancel_task(req)
+        assert response.status_code == 404  # TaskNotFoundError maps to 404
+
+    async def test_on_cancel_task_forwards_metadata_and_keeps_path_id(
+        self,
+        rest_dispatcher_instance: RestDispatcher,
+        mock_handler: AsyncMock,
+    ) -> None:
+        body = json.dumps(
+            {
+                'id': 'body_id_ignored',
+                'metadata': {'reason': 'user_aborted', 'nested': {'step': 3}},
+            }
+        ).encode('utf-8')
+        req = make_mock_request(
+            method='POST', path_params={'id': 'test_task'}, body=body
+        )
+
+        response = await rest_dispatcher_instance.on_cancel_task(req)
+        assert response.status_code == 200
+        mock_handler.on_cancel_task.assert_awaited_once()
+        cancel_params = mock_handler.on_cancel_task.call_args.args[0]
+        assert cancel_params == CancelTaskRequest(
+            id='test_task',
+            metadata={'reason': 'user_aborted', 'nested': {'step': 3}},
+        )
+
+    @pytest.mark.parametrize('body', [b'', b'   \n\t '])
+    async def test_on_cancel_task_accepts_empty_body(
+        self,
+        rest_dispatcher_instance: RestDispatcher,
+        mock_handler: AsyncMock,
+        body: bytes,
+    ) -> None:
+        req = make_mock_request(
+            method='POST', path_params={'id': 'test_task'}, body=body
+        )
+
+        response = await rest_dispatcher_instance.on_cancel_task(req)
+        assert response.status_code == 200
+        mock_handler.on_cancel_task.assert_awaited_once()
+        cancel_params = mock_handler.on_cancel_task.call_args.args[0]
+        assert cancel_params == CancelTaskRequest(id='test_task')
+        assert not cancel_params.HasField('metadata')
+
+    async def test_on_cancel_task_invalid_json_body_returns_400(
+        self,
+        rest_dispatcher_instance: RestDispatcher,
+        mock_handler: AsyncMock,
+    ) -> None:
+        req = make_mock_request(
+            method='POST', path_params={'id': 'test_task'}, body=b'{not-json'
+        )
+
+        response = await rest_dispatcher_instance.on_cancel_task(req)
+        assert response.status_code == 400
+        mock_handler.on_cancel_task.assert_not_awaited()
+
+    async def test_on_get_task_success(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        req = make_mock_request(method='GET', path_params={'id': 'test_task'})
+        response = await rest_dispatcher_instance.on_get_task(req)
+
+        assert response.status_code == 200
+        data = json.loads(response.body)
+        assert data['id'] == 'test_task'
+
+    async def test_on_get_task_not_found(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        mock_handler.on_get_task.return_value = None
+        req = make_mock_request(
+            method='GET', path_params={'id': 'missing_task'}
+        )
+
+        response = await rest_dispatcher_instance.on_get_task(req)
+        assert response.status_code == 404
+
+    async def test_list_tasks(self, rest_dispatcher_instance, mock_handler):
+        req = make_mock_request(method='GET')
+        response = await rest_dispatcher_instance.list_tasks(req)
+        assert response.status_code == 200
+
+    @pytest.mark.parametrize(
+        ('query_params', 'artifacts_expected'),
+        [
+            pytest.param(QueryParams(), False, id='default'),
+            pytest.param(
+                QueryParams({'includeArtifacts': 'true'}),
+                True,
+                id='included',
+            ),
+            pytest.param(
+                QueryParams({'includeArtifacts': 'false'}),
+                False,
+                id='excluded',
+            ),
+            pytest.param(
+                QueryParams({'includeArtifacts': 'TRUE'}),
+                True,
+                id='uppercase-true',
+            ),
+            pytest.param(
+                QueryParams({'includeArtifacts': 'False'}),
+                False,
+                id='mixed-case-false',
+            ),
+        ],
+    )
+    async def test_list_tasks_artifact_presence(
+        self,
+        rest_dispatcher_instance: RestDispatcher,
+        mock_handler: AsyncMock,
+        query_params: QueryParams,
+        artifacts_expected: bool,
+    ) -> None:
+        mock_handler.on_list_tasks.return_value = ListTasksResponse(
+            tasks=[
+                Task(
+                    id='test_task',
+                    artifacts=[Artifact(artifact_id='test-artifact')],
+                )
+            ]
+        )
+        req = make_mock_request(method='GET', query_params=query_params)
+
+        response = await rest_dispatcher_instance.list_tasks(req)
+
+        task = json.loads(response.body)['tasks'][0]
+        assert ('artifacts' in task) is artifacts_expected
+        if artifacts_expected:
+            assert task['artifacts'][0]['artifactId'] == 'test-artifact'
+
+    @pytest.mark.parametrize(
+        'value', ['garbage', '', '0', '1', ' ', ' true ', 'private-query-value']
+    )
+    async def test_list_tasks_rejects_invalid_boolean_query(
+        self, mock_handler: AsyncMock, value: str
+    ) -> None:
+        app = Starlette(routes=create_rest_routes(mock_handler))
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app),
+            base_url='http://test',
+            trust_env=False,
+        ) as client:
+            response = await client.get(
+                '/tasks',
+                params={'includeArtifacts': value},
+                headers={'a2a-version': '1.0'},
+            )
+
+        assert response.status_code == 400
+        assert response.json()['error']['status'] == 'INVALID_ARGUMENT'
+        assert 'includeArtifacts' in response.json()['error']['message']
+        if value.strip():
+            assert value not in response.json()['error']['message']
+        mock_handler.on_list_tasks.assert_not_awaited()
+
+    async def test_get_push_notification(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        req = make_mock_request(
+            method='GET', path_params={'id': 'task1', 'push_id': 'push1'}
+        )
+        response = await rest_dispatcher_instance.get_push_notification(req)
+        assert response.status_code == 200
+        data = json.loads(response.body)
+        assert data['url'] == 'http://test'
+
+    async def test_delete_push_notification(
+        self, rest_dispatcher_instance, mock_handler
+    ):
+        req = make_mock_request(
+            method='DELETE', path_params={'id': 'task1', 'push_id': 'push1'}
+        )
+        response = await rest_dispatcher_instance.delete_push_notification(req)
+        assert response.status_code == 200
+
+    async def test_handle_authenticated_agent_card(
+        self, rest_dispatcher_instance
+    ):
+        req = make_mock_request()
+        response = (
+            await rest_dispatcher_instance.handle_authenticated_agent_card(req)
+        )
+        assert response.status_code == 200
+
+
+@pytest.mark.asyncio
+class TestRestDispatcherStreaming:
+    async def test_shutdown_grace_period_is_passed_to_streaming_responses(
+        self, mock_handler
+    ) -> None:
+        async def stream(
+            context: ServerCallContext,
+        ) -> AsyncIterator[dict[str, str]]:
+            yield {'result': 'value'}
+
+        async def empty_stream(
+            context: ServerCallContext,
+        ) -> AsyncIterator[dict[str, str]]:
+            for item in []:
+                yield item
+
+        dispatcher = RestDispatcher(
+            request_handler=mock_handler,
+            shutdown_grace_period=30.0,
+        )
+        req = make_mock_request(method='POST')
+
+        response = await dispatcher._handle_streaming(req, stream)
+        empty_response = await dispatcher._handle_streaming(req, empty_stream)
+
+        assert getattr(response, '_shutdown_grace_period') == 30.0
+        assert getattr(empty_response, '_shutdown_grace_period') == 30.0
+
+    async def test_on_message_send_stream_success(
+        self, rest_dispatcher_instance
+    ):
+        req = make_mock_request(method='POST')
+        response = await rest_dispatcher_instance.on_message_send_stream(req)
+
+        assert response.status_code == 200
+
+        chunks = []
+        async for chunk in response.body_iterator:
+            chunks.append(chunk)
+
+        assert len(chunks) == 2
+        assert 'chunk1' in chunks[0].data
+        assert 'chunk2' in chunks[1].data
+
+    async def test_on_subscribe_to_task_success(self, rest_dispatcher_instance):
+        req = make_mock_request(method='GET', path_params={'id': 'test_task'})
+        response = await rest_dispatcher_instance.on_subscribe_to_task(req)
+
+        assert response.status_code == 200
+
+        chunks = []
+        async for chunk in response.body_iterator:
+            chunks.append(chunk)
+
+        assert len(chunks) == 2
+        assert 'chunk1' in chunks[0].data
+        assert 'chunk2' in chunks[1].data
+
+    async def test_on_message_send_stream_handler_error(self, mock_handler):
+        mock_handler.on_message_send_stream.side_effect = (
+            UnsupportedOperationError('Mocked error')
+        )
+
+        dispatcher = RestDispatcher(request_handler=mock_handler)
+        req = make_mock_request(method='POST')
+
+        response = await dispatcher.on_message_send_stream(req)
+        assert response.status_code == 400
+
+    async def test_streaming_does_not_ascii_escape_non_ascii(
+        self, rest_dispatcher_instance
+    ):
+        """Non-ASCII characters in SSE payloads must pass through as raw UTF-8.
+
+        Regression test for https://github.com/a2aproject/a2a-python/issues/1078.
+        """
+        non_ascii_text = '你好'
+
+        async def stream_with_non_ascii(
+            context: ServerCallContext,
+        ) -> AsyncIterator[dict]:
+            yield {'msg': {'text': non_ascii_text}}
+            yield {'msg': {'text': f'echo: {non_ascii_text}'}}
+
+        # Drive _handle_streaming directly to assert on the serialized bytes
+        # produced by json.dumps, independent of protobuf encoding details.
+        req = make_mock_request(method='POST')
+        response = await rest_dispatcher_instance._handle_streaming(
+            req, stream_with_non_ascii
+        )
+        assert response.status_code == 200
+
+        chunks = []
+        async for chunk in response.body_iterator:
+            chunks.append(chunk)
+
+        assert len(chunks) == 2
+        for chunk in chunks:
+            payload = getattr(chunk, 'data', chunk)
+            if isinstance(payload, bytes):
+                payload = payload.decode('utf-8')
+            assert non_ascii_text in payload
+            assert '\\u4f60\\u597d' not in payload
diff --git a/tests/server/routes/test_rest_routes.py b/tests/server/routes/test_rest_routes.py
new file mode 100644
index 000000000..a0450b2b0
--- /dev/null
+++ b/tests/server/routes/test_rest_routes.py
@@ -0,0 +1,181 @@
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from a2a.server.request_handlers.request_handler import RequestHandler
+from a2a.server.routes.rest_routes import create_rest_routes
+from a2a.types.a2a_pb2 import AgentCard, ListTasksResponse, Task
+from starlette.applications import Starlette
+from starlette.routing import BaseRoute
+from starlette.testclient import TestClient
+
+
+@pytest.fixture
+def agent_card():
+    return AgentCard()
+
+
+@pytest.fixture
+def mock_handler():
+    return AsyncMock(spec=RequestHandler)
+
+
+def test_routes_creation(agent_card, mock_handler):
+    """Tests that create_rest_routes creates Route objects list."""
+    routes = create_rest_routes(request_handler=mock_handler)
+
+    assert isinstance(routes, list)
+    assert len(routes) > 0
+    assert all((isinstance(r, BaseRoute) for r in routes))
+
+
+def test_routes_creation_v03_compat(agent_card, mock_handler):
+    """Tests that create_rest_routes creates more routes with enable_v0_3_compat."""
+    mock_handler._agent_card = agent_card
+    routes_without_compat = create_rest_routes(
+        request_handler=mock_handler, enable_v0_3_compat=False
+    )
+    routes_with_compat = create_rest_routes(
+        request_handler=mock_handler, enable_v0_3_compat=True
+    )
+
+    assert len(routes_with_compat) > len(routes_without_compat)
+
+
+def test_rest_endpoints_routing(agent_card, mock_handler):
+    """Tests that mounted routes route to the handler endpoints."""
+    mock_handler.on_message_send.return_value = Task(id='123')
+
+    routes = create_rest_routes(request_handler=mock_handler)
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    # Test POST /message:send
+    response = client.post(
+        '/message:send', json={}, headers={'A2A-Version': '1.0'}
+    )
+    assert response.status_code == 200
+    assert response.json()['task']['id'] == '123'
+    assert mock_handler.on_message_send.called
+
+
+@pytest.mark.parametrize(
+    'path',
+    ['/message:send', '/message:stream', '/tasks/t1/pushNotificationConfigs'],
+)
+def test_rest_invalid_utf8_body_is_bad_request(mock_handler, path):
+    """A body that is not UTF-8 is malformed JSON, so 400 rather than 500."""
+    app = Starlette(routes=create_rest_routes(request_handler=mock_handler))
+    client = TestClient(app)
+
+    response = client.post(
+        path,
+        content=b'{"message": {"messageId": "\xff"}}',
+        headers={'A2A-Version': '1.0'},
+    )
+
+    assert response.status_code == 400
+    assert response.json()['error']['status'] == 'INVALID_ARGUMENT'
+
+
+def test_rest_endpoints_routing_tenant(agent_card, mock_handler):
+    """Tests that mounted routes with {tenant} route to the handler endpoints."""
+    mock_handler.on_message_send.return_value = Task(id='123')
+
+    routes = create_rest_routes(request_handler=mock_handler)
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    # Test POST /{tenant}/message:send
+    response = client.post(
+        '/my-tenant/message:send', json={}, headers={'A2A-Version': '1.0'}
+    )
+    assert response.status_code == 200
+
+    # Verify that tenant was set in call context
+    call_args = mock_handler.on_message_send.call_args
+    assert call_args is not None
+    # call_args[0] is positional args. In on_message_send(params, context):
+    context = call_args[0][1]
+    assert context.tenant == 'my-tenant'
+
+
+def test_rest_list_tasks(agent_card, mock_handler):
+    """Tests that list tasks endpoint is routed to the handler."""
+    mock_handler.on_list_tasks.return_value = ListTasksResponse()
+
+    routes = create_rest_routes(request_handler=mock_handler)
+    app = Starlette(routes=routes)
+    client = TestClient(app)
+
+    response = client.get('/tasks', headers={'A2A-Version': '1.0'})
+    assert response.status_code == 200
+    assert mock_handler.on_list_tasks.called
+
+
+def test_shutdown_grace_period_is_forwarded_to_dispatcher(mock_handler) -> None:
+    """Tests that the route factory configures SSE cooperative shutdown."""
+    with patch(
+        'a2a.server.routes.rest_routes.RestDispatcher'
+    ) as dispatcher_class:
+        create_rest_routes(request_handler=mock_handler)
+        dispatcher_class.assert_called_once_with(
+            request_handler=mock_handler,
+            context_builder=None,
+            shutdown_grace_period=0,
+        )
+
+        dispatcher_class.reset_mock()
+        create_rest_routes(
+            request_handler=mock_handler,
+            shutdown_grace_period=30.0,
+        )
+
+        dispatcher_class.assert_called_once_with(
+            request_handler=mock_handler,
+            context_builder=None,
+            shutdown_grace_period=30.0,
+        )
+
+
+def test_shutdown_grace_period_is_forwarded_to_v03_adapter(
+    mock_handler,
+) -> None:
+    """Tests that v0.3 compatibility routes share the shutdown grace period."""
+    with patch('a2a.server.routes.rest_routes.REST03Adapter') as adapter_class:
+        adapter_class.return_value.routes.return_value = {}
+        create_rest_routes(
+            request_handler=mock_handler,
+            enable_v0_3_compat=True,
+            shutdown_grace_period=30.0,
+        )
+
+    adapter_class.assert_called_once_with(
+        http_handler=mock_handler,
+        context_builder=None,
+        shutdown_grace_period=30.0,
+    )
+
+
+def test_send_message_response_uses_the_a2a_media_type(
+    agent_card, mock_handler
+):
+    """HTTP+JSON responses are labelled application/a2a+json."""
+    mock_handler.on_message_send.return_value = Task(id='123')
+    client = TestClient(Starlette(routes=create_rest_routes(mock_handler)))
+
+    response = client.post(
+        '/message:send', json={}, headers={'A2A-Version': '1.0'}
+    )
+
+    assert response.headers['content-type'].startswith('application/a2a+json')
+
+
+def test_list_tasks_response_uses_the_a2a_media_type(agent_card, mock_handler):
+    """The list path serializes separately, so it is asserted separately."""
+    mock_handler.on_list_tasks.return_value = ListTasksResponse()
+    client = TestClient(Starlette(routes=create_rest_routes(mock_handler)))
+
+    response = client.get('/tasks', headers={'A2A-Version': '1.0'})
+
+    assert response.headers['content-type'].startswith('application/a2a+json')
diff --git a/tests/server/tasks/test_copying_task_store.py b/tests/server/tasks/test_copying_task_store.py
new file mode 100644
index 000000000..8d927003c
--- /dev/null
+++ b/tests/server/tasks/test_copying_task_store.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a.server.context import ServerCallContext
+from a2a.server.tasks.copying_task_store import CopyingTaskStoreAdapter
+from a2a.server.tasks.task_store import TaskStore
+from a2a.types.a2a_pb2 import (
+    ListTasksRequest,
+    ListTasksResponse,
+    Task,
+    TaskState,
+)
+
+
+@pytest.mark.asyncio
+async def test_copying_task_store_save():
+    """Test that the adapter makes a copy of the task when saving."""
+    mock_store = AsyncMock(spec=TaskStore)
+    adapter = CopyingTaskStoreAdapter(mock_store)
+
+    original_task = Task(
+        id='test_task', status={'state': TaskState.TASK_STATE_WORKING}
+    )
+    context = ServerCallContext()
+
+    await adapter.save(original_task, context)
+
+    # Verify underlying store was called
+    mock_store.save.assert_awaited_once()
+
+    # Get the saved task
+    saved_task = mock_store.save.call_args[0][0]
+    saved_context = mock_store.save.call_args[0][1]
+
+    # Verify context is passed correctly
+    assert saved_context is context
+
+    # Verify content is identical
+    assert saved_task.id == original_task.id
+    assert saved_task.status.state == original_task.status.state
+
+    # Verify it is a COPY, not the same reference
+    assert saved_task is not original_task
+
+
+@pytest.mark.asyncio
+async def test_copying_task_store_get():
+    """Test that the adapter returns a copy of the task retrieved."""
+    mock_store = AsyncMock(spec=TaskStore)
+    adapter = CopyingTaskStoreAdapter(mock_store)
+
+    stored_task = Task(
+        id='test_task', status={'state': TaskState.TASK_STATE_WORKING}
+    )
+    mock_store.get.return_value = stored_task
+    context = ServerCallContext()
+
+    retrieved_task = await adapter.get('test_task', context)
+
+    # Verify underlying store was called
+    mock_store.get.assert_awaited_once_with('test_task', context)
+
+    # Verify retrieved task has identical content
+    assert retrieved_task is not None
+    assert retrieved_task.id == stored_task.id
+    assert retrieved_task.status.state == stored_task.status.state
+
+    # Verify it is a COPY, not the same reference
+    assert retrieved_task is not stored_task
+
+
+@pytest.mark.asyncio
+async def test_copying_task_store_get_none():
+    """Test that the adapter properly returns None when no task is found."""
+    mock_store = AsyncMock(spec=TaskStore)
+    adapter = CopyingTaskStoreAdapter(mock_store)
+
+    mock_store.get.return_value = None
+    context = ServerCallContext()
+
+    retrieved_task = await adapter.get('test_task', context)
+
+    # Verify underlying store was called
+    mock_store.get.assert_awaited_once_with('test_task', context)
+    assert retrieved_task is None
+
+
+@pytest.mark.asyncio
+async def test_copying_task_store_list():
+    """Test that the adapter returns a copy of the list response."""
+    mock_store = AsyncMock(spec=TaskStore)
+    adapter = CopyingTaskStoreAdapter(mock_store)
+
+    task1 = Task(id='test_task_1')
+    task2 = Task(id='test_task_2')
+    stored_response = ListTasksResponse(tasks=[task1, task2])
+    mock_store.list.return_value = stored_response
+    context = ServerCallContext()
+    request = ListTasksRequest(page_size=10)
+
+    retrieved_response = await adapter.list(request, context)
+
+    # Verify underlying store was called
+    mock_store.list.assert_awaited_once_with(request, context)
+
+    # Verify retrieved response has identical content
+    assert len(retrieved_response.tasks) == 2
+    assert retrieved_response.tasks[0].id == 'test_task_1'
+    assert retrieved_response.tasks[1].id == 'test_task_2'
+
+    # Verify it is a COPY, not the same reference
+    assert retrieved_response is not stored_response
+    # Also verify inner tasks are copies
+    assert retrieved_response.tasks[0] is not task1
+    assert retrieved_response.tasks[1] is not task2
+
+
+@pytest.mark.asyncio
+async def test_copying_task_store_delete():
+    """Test that the adapter calls delete on underlying store."""
+    mock_store = AsyncMock(spec=TaskStore)
+    adapter = CopyingTaskStoreAdapter(mock_store)
+    context = ServerCallContext()
+
+    await adapter.delete('test_task', context)
+
+    # Verify underlying store was called
+    mock_store.delete.assert_awaited_once_with('test_task', context)
diff --git a/tests/server/tasks/test_database_push_notification_config_store.py b/tests/server/tasks/test_database_push_notification_config_store.py
new file mode 100644
index 000000000..5ae9aa012
--- /dev/null
+++ b/tests/server/tasks/test_database_push_notification_config_store.py
@@ -0,0 +1,951 @@
+import os
+
+from collections.abc import AsyncGenerator
+from unittest.mock import MagicMock
+
+import pytest
+
+from a2a.auth.user import User
+from a2a.compat.v0_3 import types as types_v03
+from a2a.server.context import ServerCallContext
+from sqlalchemy import insert
+
+
+# Skip entire test module if SQLAlchemy is not installed
+pytest.importorskip('sqlalchemy', reason='Database tests require SQLAlchemy')
+pytest.importorskip(
+    'cryptography',
+    reason='Database tests require Cryptography. Install extra encryption',
+)
+
+import pytest_asyncio
+
+from _pytest.mark.structures import ParameterSet
+from a2a.compat.v0_3.model_conversions import (
+    core_to_compat_push_notification_config_model,
+)
+from a2a.server.models import (
+    Base,
+    PushNotificationConfigModel,
+)  # Important: To get Base.metadata
+from a2a.server.tasks import DatabasePushNotificationConfigStore
+from a2a.types.a2a_pb2 import (
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+
+# Now safe to import SQLAlchemy-dependent modules
+from cryptography.fernet import Fernet
+from google.protobuf.json_format import MessageToJson
+from google.protobuf.timestamp_pb2 import Timestamp
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import (
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.inspection import inspect
+
+
+# DSNs for different databases
+SQLITE_TEST_DSN = (
+    'sqlite+aiosqlite:///file:testdb?mode=memory&cache=shared&uri=true'
+)
+POSTGRES_TEST_DSN = os.environ.get(
+    'POSTGRES_TEST_DSN'
+)  # e.g., "postgresql+asyncpg://user:pass@host:port/dbname"
+MYSQL_TEST_DSN = os.environ.get(
+    'MYSQL_TEST_DSN'
+)  # e.g., "mysql+aiomysql://user:pass@host:port/dbname"
+
+# Parameterization for the db_store fixture
+DB_CONFIGS: list[ParameterSet | tuple[str | None, str]] = [
+    pytest.param((SQLITE_TEST_DSN, 'sqlite'), id='sqlite')
+]
+
+if POSTGRES_TEST_DSN:
+    DB_CONFIGS.append(
+        pytest.param((POSTGRES_TEST_DSN, 'postgresql'), id='postgresql')
+    )
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'postgresql'),
+            marks=pytest.mark.skip(reason='POSTGRES_TEST_DSN not set'),
+            id='postgresql_skipped',
+        )
+    )
+
+if MYSQL_TEST_DSN:
+    DB_CONFIGS.append(pytest.param((MYSQL_TEST_DSN, 'mysql'), id='mysql'))
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'mysql'),
+            marks=pytest.mark.skip(reason='MYSQL_TEST_DSN not set'),
+            id='mysql_skipped',
+        )
+    )
+
+
+# Create a proper Timestamp for TaskStatus
+def _create_timestamp() -> Timestamp:
+    """Create a Timestamp from ISO format string."""
+    ts = Timestamp()
+    ts.FromJsonString('2023-01-01T00:00:00Z')
+    return ts
+
+
+# Minimal Task object for testing - remains the same
+task_status_submitted = TaskStatus(
+    state=TaskState.TASK_STATE_SUBMITTED, timestamp=_create_timestamp()
+)
+MINIMAL_TASK_OBJ = Task(
+    id='task-abc',
+    context_id='session-xyz',
+    status=task_status_submitted,
+    metadata={'test_key': 'test_value'},
+)
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+MINIMAL_CALL_CONTEXT = ServerCallContext(user=SampleUser(user_name='user'))
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def db_store_parameterized(
+    request,
+) -> AsyncGenerator[DatabasePushNotificationConfigStore, None]:
+    """
+    Fixture that provides a DatabaseTaskStore connected to different databases
+    based on parameterization (SQLite, PostgreSQL, MySQL).
+    """
+    db_url, dialect_name = request.param
+
+    if db_url is None:
+        pytest.skip(f'DSN for {dialect_name} not set in environment variables.')
+
+    engine = create_async_engine(db_url)
+    store = None  # Initialize store to None for the finally block
+
+    try:
+        # Create tables
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+        # create_table=False as we've explicitly created tables above.
+        store = DatabasePushNotificationConfigStore(
+            engine=engine,
+            create_table=False,
+            encryption_key=Fernet.generate_key(),
+        )
+        # Initialize the store (connects, etc.). Safe to call even if tables exist.
+        await store.initialize()
+
+        yield store
+
+    finally:
+        if engine:  # If engine was created for setup/teardown
+            # Drop tables using the fixture's engine
+            async with engine.begin() as conn:
+                await conn.run_sync(Base.metadata.drop_all)
+            await engine.dispose()  # Dispose the engine created in the fixture
+
+
+@pytest.mark.asyncio
+async def test_initialize_creates_table(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """Test that tables are created (implicitly by fixture setup)."""
+    # Ensure store is initialized (already done by fixture, but good for clarity)
+    await db_store_parameterized._ensure_initialized()
+
+    # Use the store's engine for inspection
+    async with db_store_parameterized.engine.connect() as conn:
+
+        def has_table_sync(sync_conn):
+            inspector = inspect(sync_conn)
+            return inspector.has_table(
+                PushNotificationConfigModel.__tablename__
+            )
+
+        assert await conn.run_sync(has_table_sync)
+
+
+@pytest.mark.asyncio
+async def test_initialize_is_idempotent(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """Test that tables are created (implicitly by fixture setup)."""
+    # Ensure store is initialized (already done by fixture, but good for clarity)
+    await db_store_parameterized.initialize()
+    # Call initialize again to check idempotency
+    await db_store_parameterized.initialize()
+
+
+@pytest.mark.asyncio
+async def test_set_and_get_info_single_config(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test setting and retrieving a single configuration."""
+    task_id = 'task-1'
+    config = TaskPushNotificationConfig(
+        task_id=task_id, id='config-1', url='http://example.com'
+    )
+
+    await db_store_parameterized.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert len(retrieved_configs) == 1
+    assert retrieved_configs[0] == config
+
+
+@pytest.mark.asyncio
+async def test_set_info_returns_the_stored_config_without_mutating_input(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """set_info returns what it stored and leaves the caller's config alone."""
+    task_id = 'task-normalize'
+    config = TaskPushNotificationConfig(url='http://example.com')
+
+    stored = await db_store_parameterized.set_info(
+        task_id, config, MINIMAL_CALL_CONTEXT
+    )
+
+    assert (stored.task_id, stored.id) == (task_id, task_id)
+    assert (config.task_id, config.id) == ('', '')
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+    assert retrieved_configs == [stored]
+
+
+@pytest.mark.asyncio
+async def test_set_and_get_info_multiple_configs(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test setting and retrieving multiple configurations for a single task."""
+
+    task_id = 'task-1'
+    config1 = TaskPushNotificationConfig(
+        id='config-1', task_id=task_id, url='http://example.com/1'
+    )
+    config2 = TaskPushNotificationConfig(
+        id='config-2', task_id=task_id, url='http://example.com/2'
+    )
+
+    await db_store_parameterized.set_info(
+        task_id, config1, MINIMAL_CALL_CONTEXT
+    )
+    await db_store_parameterized.set_info(
+        task_id, config2, MINIMAL_CALL_CONTEXT
+    )
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert len(retrieved_configs) == 2
+    assert config1 in retrieved_configs
+    assert config2 in retrieved_configs
+
+
+@pytest.mark.asyncio
+async def test_set_info_updates_existing_config(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that setting an existing config ID updates the record."""
+    task_id = 'task-1'
+    config_id = 'config-1'
+    initial_config = TaskPushNotificationConfig(
+        id=config_id, url='http://initial.url'
+    )
+    updated_config = TaskPushNotificationConfig(
+        id=config_id, url='http://updated.url'
+    )
+
+    await db_store_parameterized.set_info(
+        task_id, initial_config, MINIMAL_CALL_CONTEXT
+    )
+    await db_store_parameterized.set_info(
+        task_id, updated_config, MINIMAL_CALL_CONTEXT
+    )
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert len(retrieved_configs) == 1
+    assert retrieved_configs[0].url == 'http://updated.url'
+
+
+@pytest.mark.asyncio
+async def test_set_info_defaults_config_id_to_task_id(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that config.id defaults to task_id if not provided."""
+    task_id = 'task-1'
+    config = TaskPushNotificationConfig(url='http://example.com')  # id is None
+
+    await db_store_parameterized.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert len(retrieved_configs) == 1
+    assert retrieved_configs[0].id == task_id
+
+
+@pytest.mark.asyncio
+async def test_get_info_not_found(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test getting info for a task with no configs returns an empty list."""
+    retrieved_configs = await db_store_parameterized.get_info(
+        'non-existent-task', MINIMAL_CALL_CONTEXT
+    )
+    assert retrieved_configs == []
+
+
+@pytest.mark.asyncio
+async def test_delete_info_specific_config(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test deleting a single, specific configuration."""
+    task_id = 'task-1'
+    config1 = TaskPushNotificationConfig(
+        task_id=task_id, id='config-1', url='http://a.com'
+    )
+    config2 = TaskPushNotificationConfig(
+        task_id=task_id, id='config-2', url='http://b.com'
+    )
+
+    await db_store_parameterized.set_info(
+        task_id, config1, MINIMAL_CALL_CONTEXT
+    )
+    await db_store_parameterized.set_info(
+        task_id, config2, MINIMAL_CALL_CONTEXT
+    )
+
+    await db_store_parameterized.delete_info(
+        task_id, MINIMAL_CALL_CONTEXT, 'config-1'
+    )
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert len(retrieved_configs) == 1
+    assert retrieved_configs[0] == config2
+
+
+@pytest.mark.asyncio
+async def test_delete_info_all_for_task(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test deleting all configurations for a task when config_id is None."""
+
+    task_id = 'task-1'
+    config1 = TaskPushNotificationConfig(id='config-1', url='http://a.com')
+    config2 = TaskPushNotificationConfig(id='config-2', url='http://b.com')
+
+    await db_store_parameterized.set_info(
+        task_id, config1, MINIMAL_CALL_CONTEXT
+    )
+    await db_store_parameterized.set_info(
+        task_id, config2, MINIMAL_CALL_CONTEXT
+    )
+
+    await db_store_parameterized.delete_info(
+        task_id, MINIMAL_CALL_CONTEXT, None
+    )
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    assert retrieved_configs == []
+
+
+@pytest.mark.asyncio
+async def test_delete_info_not_found(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that deleting a non-existent config does not raise an error."""
+    # Should not raise
+    await db_store_parameterized.delete_info(
+        'task-1', MINIMAL_CALL_CONTEXT, 'non-existent-config'
+    )
+
+
+@pytest.mark.asyncio
+async def test_data_is_encrypted_in_db(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Verify that the data stored in the database is actually encrypted."""
+    task_id = 'encrypted-task'
+    config = TaskPushNotificationConfig(
+        task_id=task_id,
+        id='config-1',
+        url='http://secret.url',
+        token='secret-token',
+    )
+    plain_json = MessageToJson(config)
+
+    await db_store_parameterized.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+    # Directly query the database to inspect the raw data
+    async_session = async_sessionmaker(
+        db_store_parameterized.engine, expire_on_commit=False
+    )
+    async with async_session() as session:
+        stmt = select(PushNotificationConfigModel).where(
+            PushNotificationConfigModel.task_id == task_id
+        )
+        result = await session.execute(stmt)
+        db_model = result.scalar_one()
+
+    assert db_model.config_data != plain_json.encode('utf-8')
+
+    fernet = db_store_parameterized._fernet
+
+    decrypted_data = fernet.decrypt(db_model.config_data)  # type: ignore
+    assert decrypted_data.decode('utf-8') == plain_json
+
+
+@pytest.mark.asyncio
+async def test_decryption_error_with_wrong_key(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that using the wrong key to decrypt raises a ValueError."""
+    # 1. Store with one key
+
+    task_id = 'wrong-key-task'
+    config = TaskPushNotificationConfig(id='config-1', url='http://secret.url')
+    await db_store_parameterized.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+    # 2. Try to read with a different key
+    # Directly query the database to inspect the raw data
+    wrong_key = Fernet.generate_key()
+    store2 = DatabasePushNotificationConfigStore(
+        db_store_parameterized.engine, encryption_key=wrong_key
+    )
+
+    retrieved_configs = await store2.get_info(task_id, MINIMAL_CALL_CONTEXT)
+    assert retrieved_configs == []
+
+    # _from_orm should raise a ValueError
+    async_session = async_sessionmaker(
+        db_store_parameterized.engine, expire_on_commit=False
+    )
+    async with async_session() as session:
+        db_model = await session.get(
+            PushNotificationConfigModel, (task_id, 'config-1')
+        )
+
+        with pytest.raises(ValueError):
+            store2._from_orm(db_model)  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_decryption_error_with_no_key(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that using the wrong key to decrypt raises a ValueError."""
+    # 1. Store with one key
+
+    task_id = 'wrong-key-task'
+    config = TaskPushNotificationConfig(id='config-1', url='http://secret.url')
+    await db_store_parameterized.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+    # 2. Try to read with no key set
+    # Directly query the database to inspect the raw data
+    store2 = DatabasePushNotificationConfigStore(db_store_parameterized.engine)
+
+    retrieved_configs = await store2.get_info(task_id, MINIMAL_CALL_CONTEXT)
+    assert retrieved_configs == []
+
+    # _from_orm should raise a ValueError
+    async_session = async_sessionmaker(
+        db_store_parameterized.engine, expire_on_commit=False
+    )
+    async with async_session() as session:
+        db_model = await session.get(
+            PushNotificationConfigModel, (task_id, 'config-1')
+        )
+
+        with pytest.raises(ValueError):
+            store2._from_orm(db_model)  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_custom_table_name(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that the store works correctly with a custom table name."""
+    table_name = 'my_custom_push_configs'
+    engine = db_store_parameterized.engine
+    custom_store = None
+    try:
+        # Use a new store with a custom table name
+        custom_store = DatabasePushNotificationConfigStore(
+            engine=engine,
+            create_table=True,
+            table_name=table_name,
+            encryption_key=Fernet.generate_key(),
+        )
+
+        task_id = 'custom-table-task'
+        config = TaskPushNotificationConfig(
+            task_id=task_id, id='config-1', url='http://custom.url'
+        )
+
+        # This will create the table on first use
+        await custom_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+        retrieved_configs = await custom_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+
+        assert len(retrieved_configs) == 1
+        assert retrieved_configs[0] == config
+
+        # Verify the custom table exists and has data
+        async with custom_store.engine.connect() as conn:
+
+            def has_table_sync(sync_conn):
+                inspector = inspect(sync_conn)
+                return inspector.has_table(table_name)
+
+            assert await conn.run_sync(has_table_sync)
+
+            result = await conn.execute(
+                select(custom_store.config_model).where(
+                    custom_store.config_model.task_id == task_id
+                )
+            )
+            assert result.scalar_one_or_none() is not None
+    finally:
+        if custom_store:
+            # Clean up the dynamically created table from the metadata
+            # to prevent errors in subsequent parameterized test runs.
+            Base.metadata.remove(custom_store.config_model.__table__)  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_set_and_get_info_multiple_configs_no_key(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test setting and retrieving multiple configurations for a single task."""
+
+    store = DatabasePushNotificationConfigStore(
+        engine=db_store_parameterized.engine,
+        create_table=False,
+        encryption_key=None,  # No encryption key
+    )
+    await store.initialize()
+
+    task_id = 'task-1'
+    config1 = TaskPushNotificationConfig(
+        task_id=task_id, id='config-1', url='http://example.com/1'
+    )
+    config2 = TaskPushNotificationConfig(
+        task_id=task_id, id='config-2', url='http://example.com/2'
+    )
+
+    await store.set_info(task_id, config1, MINIMAL_CALL_CONTEXT)
+    await store.set_info(task_id, config2, MINIMAL_CALL_CONTEXT)
+    retrieved_configs = await store.get_info(task_id, MINIMAL_CALL_CONTEXT)
+
+    assert len(retrieved_configs) == 2
+    assert config1 in retrieved_configs
+    assert config2 in retrieved_configs
+
+
+@pytest.mark.asyncio
+async def test_data_is_not_encrypted_in_db_if_no_key_is_set(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test data is not encrypted when no encryption key is set."""
+
+    store = DatabasePushNotificationConfigStore(
+        engine=db_store_parameterized.engine,
+        create_table=False,
+        encryption_key=None,  # No encryption key
+    )
+    await store.initialize()
+
+    task_id = 'task-1'
+    config = TaskPushNotificationConfig(
+        task_id=task_id, id='config-1', url='http://example.com/1'
+    )
+    plain_json = MessageToJson(config)
+
+    await store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+    # Directly query the database to inspect the raw data
+    async_session = async_sessionmaker(
+        db_store_parameterized.engine, expire_on_commit=False
+    )
+    async with async_session() as session:
+        stmt = select(PushNotificationConfigModel).where(
+            PushNotificationConfigModel.task_id == task_id
+        )
+        result = await session.execute(stmt)
+        db_model = result.scalar_one()
+
+    assert db_model.config_data == plain_json.encode('utf-8')
+
+
+@pytest.mark.asyncio
+async def test_decryption_fallback_for_unencrypted_data(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test reading unencrypted data with an encryption-enabled store."""
+    # 1. Store unencrypted data using a new store instance without a key
+    unencrypted_store = DatabasePushNotificationConfigStore(
+        engine=db_store_parameterized.engine,
+        create_table=False,  # Table already exists from fixture
+        encryption_key=None,
+    )
+    await unencrypted_store.initialize()
+
+    task_id = 'mixed-encryption-task'
+    config = TaskPushNotificationConfig(
+        task_id=task_id, id='config-1', url='http://plain.url'
+    )
+    await unencrypted_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+    # 2. Try to read with the encryption-enabled store from the fixture
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+
+    # Should fall back to parsing as plain JSON and not fail
+    assert len(retrieved_configs) == 1
+    assert retrieved_configs[0] == config
+
+
+@pytest.mark.asyncio
+async def test_parsing_error_after_successful_decryption(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+):
+    """Test that a parsing error after successful decryption is handled."""
+
+    task_id = 'corrupted-data-task'
+    config_id = 'config-1'
+
+    # 1. Encrypt data that is NOT valid JSON
+    fernet = Fernet(Fernet.generate_key())
+    corrupted_payload = b'this is not valid json'
+    encrypted_data = fernet.encrypt(corrupted_payload)
+
+    # 2. Manually insert this corrupted data into the DB
+    async_session = async_sessionmaker(
+        db_store_parameterized.engine, expire_on_commit=False
+    )
+    async with async_session() as session:
+        db_model = PushNotificationConfigModel(
+            task_id=task_id,
+            config_id=config_id,
+            config_data=encrypted_data,
+            owner='user',
+        )
+        session.add(db_model)
+        await session.commit()
+
+    # 3. get_info should log an error and return an empty list
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, MINIMAL_CALL_CONTEXT
+    )
+    assert retrieved_configs == []
+
+    # 4. _from_orm should raise a ValueError
+    async with async_session() as session:
+        db_model_retrieved = await session.get(
+            PushNotificationConfigModel, (task_id, config_id)
+        )
+
+        with pytest.raises(ValueError):
+            db_store_parameterized._from_orm(db_model_retrieved)  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_owner_resource_scoping(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """Test that operations are scoped to the correct owner."""
+    config_store = db_store_parameterized
+
+    context_user1 = ServerCallContext(user=SampleUser(user_name='user1'))
+    context_user2 = ServerCallContext(user=SampleUser(user_name='user2'))
+
+    # Create configs for different owners
+    task1_u1_config1 = TaskPushNotificationConfig(
+        id='t1-u1-c1', url='http://u1.com/1'
+    )
+    task1_u1_config2 = TaskPushNotificationConfig(
+        id='t1-u1-c2', url='http://u1.com/2'
+    )
+    task1_u2_config1 = TaskPushNotificationConfig(
+        id='t1-u2-c1', url='http://u2.com/1'
+    )
+    task2_u1_config1 = TaskPushNotificationConfig(
+        id='t2-u1-c1', url='http://u1.com/3'
+    )
+
+    await config_store.set_info('task1', task1_u1_config1, context_user1)
+    await config_store.set_info('task1', task1_u1_config2, context_user1)
+    await config_store.set_info('task1', task1_u2_config1, context_user2)
+    await config_store.set_info('task2', task2_u1_config1, context_user1)
+
+    # Test GET_INFO
+    # User 1 should get only their configs for task1
+    u1_task1_configs = await config_store.get_info('task1', context_user1)
+    assert len(u1_task1_configs) == 2
+    assert {c.id for c in u1_task1_configs} == {'t1-u1-c1', 't1-u1-c2'}
+
+    # User 2 should get only their configs for task1
+    u2_task1_configs = await config_store.get_info('task1', context_user2)
+    assert len(u2_task1_configs) == 1
+    assert u2_task1_configs[0].id == 't1-u2-c1'
+
+    # User 2 should get no configs for task2
+    u2_task2_configs = await config_store.get_info('task2', context_user2)
+    assert len(u2_task2_configs) == 0
+
+    # User 1 should get their config for task2
+    u1_task2_configs = await config_store.get_info('task2', context_user1)
+    assert len(u1_task2_configs) == 1
+    assert u1_task2_configs[0].id == 't2-u1-c1'
+
+    # Test DELETE_INFO
+    # User 2 deleting User 1's config should not work
+    await config_store.delete_info('task1', context_user2, 't1-u1-c1')
+    u1_task1_configs = await config_store.get_info('task1', context_user1)
+    assert len(u1_task1_configs) == 2
+
+    # User 1 deleting their own config
+    await config_store.delete_info(
+        'task1',
+        context_user1,
+        't1-u1-c1',
+    )
+    u1_task1_configs = await config_store.get_info('task1', context_user1)
+    assert len(u1_task1_configs) == 1
+    assert u1_task1_configs[0].id == 't1-u1-c2'
+
+    # User 1 deleting all configs for task2
+    await config_store.delete_info('task2', context=context_user1)
+    u1_task2_configs = await config_store.get_info('task2', context_user1)
+    assert len(u1_task2_configs) == 0
+
+    # Cleanup remaining
+    await config_store.delete_info('task1', context=context_user1)
+    await config_store.delete_info('task1', context=context_user2)
+
+
+@pytest.mark.asyncio
+async def test_get_info_for_dispatch_returns_all_owners(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """get_info_for_dispatch MUST return configs across all owners.
+
+    The dispatch path has no caller identity (the originating request
+    has completed by the time notifications fire). Authorization
+    happened at registration time. The DB query must therefore filter
+    on task_id only, with no owner predicate.
+    """
+    config_store = db_store_parameterized
+
+    alice_ctx = ServerCallContext(user=SampleUser(user_name='alice'))
+    bob_ctx = ServerCallContext(user=SampleUser(user_name='bob'))
+
+    alice_cfg = TaskPushNotificationConfig(
+        id='alice-cfg', url='http://alice.example.com/cb'
+    )
+    bob_cfg = TaskPushNotificationConfig(
+        id='bob-cfg', url='http://bob.example.com/cb'
+    )
+    other_task_cfg = TaskPushNotificationConfig(
+        id='alice-other', url='http://alice.example.com/other'
+    )
+
+    await config_store.set_info('shared-task', alice_cfg, alice_ctx)
+    await config_store.set_info('shared-task', bob_cfg, bob_ctx)
+    # An unrelated config on a different task -- must NOT leak through.
+    await config_store.set_info('other-task', other_task_cfg, alice_ctx)
+
+    dispatched = await config_store.get_info_for_dispatch('shared-task')
+
+    assert {c.id for c in dispatched} == {'alice-cfg', 'bob-cfg'}
+    assert {c.url for c in dispatched} == {
+        'http://alice.example.com/cb',
+        'http://bob.example.com/cb',
+    }
+
+    # Sanity: user-callable get_info remains owner-scoped on the same data.
+    alice_view = await config_store.get_info('shared-task', alice_ctx)
+    assert {c.id for c in alice_view} == {'alice-cfg'}
+    bob_view = await config_store.get_info('shared-task', bob_ctx)
+    assert {c.id for c in bob_view} == {'bob-cfg'}
+
+    # Cleanup
+    await config_store.delete_info('shared-task', context=alice_ctx)
+    await config_store.delete_info('shared-task', context=bob_ctx)
+    await config_store.delete_info('other-task', context=alice_ctx)
+
+
+@pytest.mark.asyncio
+async def test_get_0_3_push_notification_config_detailed(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """Test retrieving a legacy v0.3 push notification config from the database.
+
+    This test simulates a database that already contains legacy v0.3 JSON data
+    and verifies that the store correctly converts it to the modern Protobuf model.
+    """
+    task_id = 'legacy-push-1'
+    config_id = 'config-legacy-1'
+    owner = 'legacy_user'
+    context_user = ServerCallContext(user=SampleUser(user_name=owner))
+
+    # 1. Create a legacy PushNotificationConfig using v0.3 models
+    legacy_config = types_v03.PushNotificationConfig(
+        id=config_id,
+        url='https://example.com/push',
+        token='legacy-token',
+        authentication=types_v03.PushNotificationAuthenticationInfo(
+            schemes=['bearer'],
+            credentials='legacy-creds',
+        ),
+    )
+
+    # 2. Manually insert the legacy data into the database
+    # For PushNotificationConfigStore, the data is stored in the config_data column.
+    async with db_store_parameterized.async_session_maker.begin() as session:
+        # Pydantic model_dump_json() produces the JSON that we'll store.
+        # Note: DatabasePushNotificationConfigStore normally encrypts this, but here
+        # we'll store it as plain JSON bytes to simulate legacy data.
+        legacy_json = legacy_config.model_dump_json()
+
+        stmt = insert(db_store_parameterized.config_model).values(
+            task_id=task_id,
+            config_id=config_id,
+            owner=owner,
+            config_data=legacy_json.encode('utf-8'),
+        )
+        await session.execute(stmt)
+
+    # 3. Retrieve the config using the standard store.get_info()
+    # This will trigger the DatabasePushNotificationConfigStore._from_orm legacy conversion
+    retrieved_configs = await db_store_parameterized.get_info(
+        task_id, context_user
+    )
+
+    # 4. Verify the conversion to modern Protobuf
+    assert len(retrieved_configs) == 1
+    retrieved = retrieved_configs[0]
+    assert retrieved.task_id == task_id
+    assert retrieved.id == config_id
+    assert retrieved.url == 'https://example.com/push'
+    assert retrieved.token == 'legacy-token'
+    assert retrieved.authentication.scheme == 'bearer'
+    assert retrieved.authentication.credentials == 'legacy-creds'
+
+
+@pytest.mark.asyncio
+async def test_custom_conversion():
+    engine = MagicMock()
+
+    # Custom callables
+    mock_to_orm = MagicMock(
+        return_value=PushNotificationConfigModel(task_id='t1', config_id='c1')
+    )
+    mock_from_orm = MagicMock(
+        return_value=TaskPushNotificationConfig(id='custom_config')
+    )
+    store = DatabasePushNotificationConfigStore(
+        engine=engine,
+        core_to_model_conversion=mock_to_orm,
+        model_to_core_conversion=mock_from_orm,
+    )
+
+    config = TaskPushNotificationConfig(id='orig')
+    model = store._to_orm('t1', config, 'owner')
+    assert model.config_id == 'c1'
+    mock_to_orm.assert_called_once_with('t1', config, 'owner', None)
+
+    model_instance = PushNotificationConfigModel(task_id='t1', config_id='c1')
+    loaded_config = store._from_orm(model_instance)
+    assert loaded_config.id == 'custom_config'
+    mock_from_orm.assert_called_once_with(model_instance)
+
+
+@pytest.mark.asyncio
+async def test_core_to_0_3_model_conversion(
+    db_store_parameterized: DatabasePushNotificationConfigStore,
+) -> None:
+    """Test storing and retrieving push notification configs in v0.3 format using conversion utilities.
+
+    Tests both class-level and instance-level assignment of the conversion function.
+    Setting the model_to_core_conversion to compat_push_notification_config_model_to_core would be redundant as
+    it is always called when retrieving 0.3 PushNotificationConfigs.
+    """
+    store = db_store_parameterized
+
+    # Set the v0.3 persistence utilities
+    store.core_to_model_conversion = (
+        core_to_compat_push_notification_config_model
+    )
+
+    task_id = 'v03-persistence-task'
+    config_id = 'c1'
+    original_config = TaskPushNotificationConfig(
+        id=config_id,
+        url='https://example.com/push',
+        token='legacy-token',
+    )
+    # 1. Save the config (will use core_to_compat_push_notification_config_model)
+    await store.set_info(task_id, original_config, MINIMAL_CALL_CONTEXT)
+
+    # 2. Verify it's stored in v0.3 format directly in DB
+    async with store.async_session_maker() as session:
+        db_model = await session.get(store.config_model, (task_id, config_id))
+        assert db_model is not None
+        assert db_model.protocol_version == '0.3'
+        # v0.3 JSON structure for PushNotificationConfig (unwrapped)
+        import json
+
+        raw_data = db_model.config_data
+        if store._fernet:
+            raw_data = store._fernet.decrypt(raw_data)
+        data = json.loads(raw_data.decode('utf-8'))
+        assert data['url'] == 'https://example.com/push'
+        assert data['id'] == 'c1'
+        assert data['token'] == 'legacy-token'
+        assert 'taskId' not in data
+
+    # 3. Retrieve the config (will use compat_push_notification_config_model_to_core)
+    retrieved_configs = await store.get_info(task_id, MINIMAL_CALL_CONTEXT)
+    assert len(retrieved_configs) == 1
+    retrieved = retrieved_configs[0]
+    assert retrieved.id == original_config.id
+    assert retrieved.url == original_config.url
+    assert retrieved.token == original_config.token
+
+    # Reset conversion attributes
+    store.core_to_model_conversion = None
+    await store.delete_info(task_id, MINIMAL_CALL_CONTEXT)
diff --git a/tests/server/tasks/test_database_task_store.py b/tests/server/tasks/test_database_task_store.py
new file mode 100644
index 000000000..d0e1b3dc6
--- /dev/null
+++ b/tests/server/tasks/test_database_task_store.py
@@ -0,0 +1,1200 @@
+import os
+
+from base64 import urlsafe_b64encode
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+import pytest_asyncio
+
+from _pytest.mark.structures import ParameterSet
+from a2a.compat.v0_3 import types as types_v03
+from a2a.types.a2a_pb2 import ListTasksRequest
+from sqlalchemy import event, insert
+from sqlalchemy.engine import Connection, ExecutionContext
+
+
+# Skip entire test module if SQLAlchemy is not installed
+pytest.importorskip('sqlalchemy', reason='Database tests require SQLAlchemy')
+
+# Now safe to import SQLAlchemy-dependent modules
+from a2a.auth.user import User
+from a2a.compat.v0_3.model_conversions import core_to_compat_task_model
+from a2a.server.context import ServerCallContext
+from a2a.server.models import Base, TaskModel  # Important: To get Base.metadata
+from a2a.server.tasks.database_task_store import DatabaseTaskStore
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    Message,
+    Part,
+    Role,
+    Task,
+    TaskState,
+    TaskStatus,
+)
+from a2a.utils.constants import DEFAULT_LIST_TASKS_PAGE_SIZE
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.task import (
+    ListTasksCursor,
+    decode_list_tasks_cursor,
+    encode_list_tasks_cursor,
+)
+from google.protobuf.json_format import MessageToDict
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.inspection import inspect
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+
+def _decoded_cursor(page_token: str) -> tuple[datetime | None, str] | None:
+    """The (timestamp, task ID) a page token resumes after; None on the last page."""
+    if not page_token:
+        return None
+    cursor = decode_list_tasks_cursor(page_token)
+    assert cursor is not None, 'expected a cursor token, not a legacy one'
+    timestamp = (
+        datetime(1970, 1, 1, tzinfo=timezone.utc)
+        + timedelta(microseconds=cursor.timestamp_ns // 1_000)
+        if cursor.timestamp_ns is not None
+        else None
+    )
+    return (timestamp, cursor.task_id)
+
+
+# DSNs for different databases
+SQLITE_TEST_DSN = (
+    'sqlite+aiosqlite:///file:testdb?mode=memory&cache=shared&uri=true'
+)
+POSTGRES_TEST_DSN = os.environ.get(
+    'POSTGRES_TEST_DSN'
+)  # e.g., "postgresql+asyncpg://user:pass@host:port/dbname"
+MYSQL_TEST_DSN = os.environ.get(
+    'MYSQL_TEST_DSN'
+)  # e.g., "mysql+aiomysql://user:pass@host:port/dbname"
+
+# Parameterization for the db_store fixture
+DB_CONFIGS: list[ParameterSet | tuple[str | None, str]] = [
+    pytest.param((SQLITE_TEST_DSN, 'sqlite'), id='sqlite')
+]
+
+if POSTGRES_TEST_DSN:
+    DB_CONFIGS.append(
+        pytest.param((POSTGRES_TEST_DSN, 'postgresql'), id='postgresql')
+    )
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'postgresql'),
+            marks=pytest.mark.skip(reason='POSTGRES_TEST_DSN not set'),
+            id='postgresql_skipped',
+        )
+    )
+
+if MYSQL_TEST_DSN:
+    DB_CONFIGS.append(pytest.param((MYSQL_TEST_DSN, 'mysql'), id='mysql'))
+else:
+    DB_CONFIGS.append(
+        pytest.param(
+            (None, 'mysql'),
+            marks=pytest.mark.skip(reason='MYSQL_TEST_DSN not set'),
+            id='mysql_skipped',
+        )
+    )
+
+
+# Minimal Task object for testing - remains the same
+task_status_submitted = TaskStatus(state=TaskState.TASK_STATE_SUBMITTED)
+MINIMAL_TASK_OBJ = Task(
+    id='task-abc',
+    context_id='session-xyz',
+    status=task_status_submitted,
+)
+
+
+@pytest_asyncio.fixture(params=DB_CONFIGS)
+async def db_store_parameterized(
+    request,
+) -> AsyncGenerator[DatabaseTaskStore, None]:
+    """
+    Fixture that provides a DatabaseTaskStore connected to different databases
+    based on parameterization (SQLite, PostgreSQL, MySQL).
+    """
+    db_url, dialect_name = request.param
+
+    if db_url is None:
+        pytest.skip(f'DSN for {dialect_name} not set in environment variables.')
+
+    engine = create_async_engine(db_url)
+    store = None  # Initialize store to None for the finally block
+
+    try:
+        # Create tables
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+        # create_table=False as we've explicitly created tables above.
+        store = DatabaseTaskStore(engine=engine, create_table=False)
+        # Initialize the store (connects, etc.). Safe to call even if tables exist.
+        await store.initialize()
+
+        yield store
+
+    finally:
+        if engine:  # If engine was created for setup/teardown
+            # Drop tables using the fixture's engine
+            async with engine.begin() as conn:
+                await conn.run_sync(Base.metadata.drop_all)
+            await engine.dispose()  # Dispose the engine created in the fixture
+
+
+@pytest.mark.asyncio
+async def test_initialize_creates_table(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test that tables are created (implicitly by fixture setup)."""
+    # Ensure store is initialized (already done by fixture, but good for clarity)
+    await db_store_parameterized._ensure_initialized()
+
+    # Use the store's engine for inspection
+    async with db_store_parameterized.engine.connect() as conn:
+
+        def has_table_sync(sync_conn):
+            inspector = inspect(sync_conn)
+            return inspector.has_table(TaskModel.__tablename__)
+
+        assert await conn.run_sync(has_table_sync)
+
+
+@pytest.mark.asyncio
+async def test_save_task(db_store_parameterized: DatabaseTaskStore) -> None:
+    """Test saving a task to the DatabaseTaskStore."""
+    # Create a copy of the minimal task with a unique ID
+    task_to_save = Task()
+    task_to_save.CopyFrom(MINIMAL_TASK_OBJ)
+    # Ensure unique ID for parameterized tests if needed, or rely on table isolation
+    task_to_save.id = (
+        f'save-task-{db_store_parameterized.engine.url.drivername}'
+    )
+    await db_store_parameterized.save(task_to_save, TEST_CONTEXT)
+
+    retrieved_task = await db_store_parameterized.get(
+        task_to_save.id, TEST_CONTEXT
+    )
+    assert retrieved_task is not None
+    assert retrieved_task.id == task_to_save.id
+    assert MessageToDict(retrieved_task) == MessageToDict(task_to_save)
+    await db_store_parameterized.delete(
+        task_to_save.id, TEST_CONTEXT
+    )  # Cleanup
+
+
+@pytest.mark.asyncio
+async def test_get_task(db_store_parameterized: DatabaseTaskStore) -> None:
+    """Test retrieving a task from the DatabaseTaskStore."""
+    task_id = f'get-test-task-{db_store_parameterized.engine.url.drivername}'
+    task_to_save = Task()
+    task_to_save.CopyFrom(MINIMAL_TASK_OBJ)
+    task_to_save.id = task_id
+    await db_store_parameterized.save(task_to_save, TEST_CONTEXT)
+
+    retrieved_task = await db_store_parameterized.get(
+        task_to_save.id, TEST_CONTEXT
+    )
+    assert retrieved_task is not None
+    assert retrieved_task.id == task_to_save.id
+    assert retrieved_task.context_id == task_to_save.context_id
+    assert retrieved_task.status.state == TaskState.TASK_STATE_SUBMITTED
+    await db_store_parameterized.delete(
+        task_to_save.id, TEST_CONTEXT
+    )  # Cleanup
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'params, expected_ids, total_count, next_cursor',
+    [
+        # No parameters, should return all tasks
+        (
+            ListTasksRequest(),
+            ['task-2', 'task-1', 'task-0', 'task-4', 'task-3'],
+            5,
+            None,
+        ),
+        # Unknown context
+        (
+            ListTasksRequest(context_id='nonexistent'),
+            [],
+            0,
+            None,
+        ),
+        # Pagination (first page)
+        (
+            ListTasksRequest(page_size=2),
+            ['task-2', 'task-1'],
+            5,
+            (datetime(2025, 1, 1, tzinfo=timezone.utc), 'task-1'),
+        ),
+        # Pagination (same timestamp)
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0x',  # base64 for 'task-1'
+            ),
+            ['task-1', 'task-0'],
+            5,
+            (datetime(2025, 1, 1, tzinfo=timezone.utc), 'task-0'),
+        ),
+        # Pagination (final page)
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0z',  # base64 for 'task-3'
+            ),
+            ['task-3'],
+            5,
+            None,
+        ),
+        # Filtering by context_id
+        (
+            ListTasksRequest(context_id='context-1'),
+            ['task-1', 'task-3'],
+            2,
+            None,
+        ),
+        # Filtering by status
+        (
+            ListTasksRequest(status=TaskState.TASK_STATE_WORKING),
+            ['task-1', 'task-3'],
+            2,
+            None,
+        ),
+        # Combined filtering (context_id and status)
+        (
+            ListTasksRequest(
+                context_id='context-0', status=TaskState.TASK_STATE_SUBMITTED
+            ),
+            ['task-2', 'task-0'],
+            2,
+            None,
+        ),
+        # Combined filtering and pagination
+        (
+            ListTasksRequest(
+                context_id='context-0',
+                page_size=1,
+            ),
+            ['task-2'],
+            3,
+            (datetime(2025, 1, 2, tzinfo=timezone.utc), 'task-2'),
+        ),
+    ],
+)
+async def test_list_tasks(
+    db_store_parameterized: DatabaseTaskStore,
+    params: ListTasksRequest,
+    expected_ids: list[str],
+    total_count: int,
+    next_cursor: tuple[datetime, str] | None,
+) -> None:
+    """Test listing tasks with various filters and pagination."""
+    tasks_to_create = [
+        Task(
+            id='task-0',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-1',
+            context_id='context-1',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_WORKING,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-2',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 2, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-3',
+            context_id='context-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        ),
+        Task(
+            id='task-4',
+            context_id='context-0',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        ),
+    ]
+    for task in tasks_to_create:
+        await db_store_parameterized.save(task, TEST_CONTEXT)
+
+    page = await db_store_parameterized.list(params, TEST_CONTEXT)
+
+    retrieved_ids = [task.id for task in page.tasks]
+    assert retrieved_ids == expected_ids
+    assert page.total_size == total_count
+    assert _decoded_cursor(page.next_page_token) == next_cursor
+    assert page.page_size == (params.page_size or DEFAULT_LIST_TASKS_PAGE_SIZE)
+
+    # Cleanup
+    for task in tasks_to_create:
+        await db_store_parameterized.delete(task.id, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_list_tasks_does_not_bind_out_of_range_datetimes(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test list ordering without out-of-range datetime sentinels."""
+    bound_datetimes: list[datetime] = []
+    compiled_execution_count = 0
+
+    def capture_bound_datetimes(
+        _conn: Connection,
+        _cursor: Any,
+        _statement: str,
+        _parameters: Any,
+        context: ExecutionContext,
+        _executemany: bool,
+    ) -> None:
+        nonlocal compiled_execution_count
+        if context.compiled is None:
+            return
+        compiled_execution_count += 1
+        bound_datetimes.extend(
+            value
+            for value in context.compiled.params.values()
+            if isinstance(value, datetime)
+        )
+
+    event.listen(
+        db_store_parameterized.engine.sync_engine,
+        'before_cursor_execute',
+        capture_bound_datetimes,
+    )
+    try:
+        await db_store_parameterized.list(ListTasksRequest(), TEST_CONTEXT)
+    finally:
+        event.remove(
+            db_store_parameterized.engine.sync_engine,
+            'before_cursor_execute',
+            capture_bound_datetimes,
+        )
+
+    assert compiled_execution_count > 0
+    assert all(value.year >= 1000 for value in bound_datetimes)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'state, legacy_state',
+    [
+        (TaskState.TASK_STATE_SUBMITTED, 'submitted'),
+        (TaskState.TASK_STATE_WORKING, 'working'),
+        (TaskState.TASK_STATE_COMPLETED, 'completed'),
+        (TaskState.TASK_STATE_FAILED, 'failed'),
+        (TaskState.TASK_STATE_CANCELED, 'canceled'),
+        (TaskState.TASK_STATE_INPUT_REQUIRED, 'input-required'),
+        (TaskState.TASK_STATE_REJECTED, 'rejected'),
+        (TaskState.TASK_STATE_AUTH_REQUIRED, 'auth-required'),
+    ],
+)
+async def test_list_tasks_filters_mixed_protocol_states(
+    db_store_parameterized: DatabaseTaskStore,
+    state: TaskState.ValueType,
+    legacy_state: str,
+) -> None:
+    store = db_store_parameterized
+    other_context = ServerCallContext(user=SampleUser('other_user'))
+    for owner_context in (TEST_CONTEXT, other_context):
+        owner = store.owner_resolver(owner_context)
+        for prefix, core_state, stored_state in (
+            ('match', state, legacy_state),
+            ('nonmatch', TaskState.TASK_STATE_UNSPECIFIED, 'unknown'),
+        ):
+            await store.save(
+                Task(
+                    id=f'{owner}-{prefix}-modern',
+                    context_id='mixed-context',
+                    status=TaskStatus(state=core_state),
+                ),
+                owner_context,
+            )
+            async with store.async_session_maker.begin() as session:
+                for version in (None, '0.3'):
+                    await session.execute(
+                        insert(store.task_model).values(
+                            id=f'{owner}-{prefix}-legacy-{version}',
+                            context_id='mixed-context',
+                            owner=owner,
+                            status={'state': stored_state},
+                            protocol_version=version,
+                        )
+                    )
+
+    owner = store.owner_resolver(TEST_CONTEXT)
+    expected_ids = [
+        f'{owner}-match-modern',
+        f'{owner}-match-legacy-None',
+        f'{owner}-match-legacy-0.3',
+    ]
+    for params in (
+        ListTasksRequest(),
+        ListTasksRequest(status=TaskState.TASK_STATE_UNSPECIFIED),
+    ):
+        unfiltered = await store.list(params, TEST_CONTEXT)
+        assert unfiltered.total_size == 6
+        assert {task.id for task in unfiltered.tasks} == {
+            task_id.replace('-match-', f'-{prefix}-')
+            for task_id in expected_ids
+            for prefix in ('match', 'nonmatch')
+        }
+
+    params = ListTasksRequest(status=state, page_size=1)
+    for index, expected_id in enumerate(expected_ids):
+        page = await store.list(params, TEST_CONTEXT)
+        assert page.total_size == 3
+        assert [task.id for task in page.tasks] == [expected_id]
+        assert page.tasks[0].status.state == state
+        assert page.page_size == 1
+        assert bool(page.next_page_token) == (index < len(expected_ids) - 1)
+        params.page_token = page.next_page_token
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'params, expected_error_message',
+    [
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='invalid',
+            ),
+            'Token is not a valid base64-encoded cursor.',
+        ),
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0xMDA=',  # base64 for 'task-100'
+            ),
+            'Invalid page token: dGFzay0xMDA=',
+        ),
+    ],
+)
+async def test_list_tasks_fails(
+    db_store_parameterized: DatabaseTaskStore,
+    params: ListTasksRequest,
+    expected_error_message: str,
+) -> None:
+    """Test listing tasks with invalid parameters that should fail."""
+    tasks_to_create = [
+        Task(
+            id='task-0',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-1',
+            context_id='context-1',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_WORKING,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+    ]
+    for task in tasks_to_create:
+        await db_store_parameterized.save(task, TEST_CONTEXT)
+
+    with pytest.raises(InvalidParamsError) as excinfo:
+        await db_store_parameterized.list(params, TEST_CONTEXT)
+
+    assert expected_error_message in str(excinfo.value)
+
+    # Cleanup
+    for task in tasks_to_create:
+        await db_store_parameterized.delete(task.id, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_get_nonexistent_task(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test retrieving a nonexistent task."""
+    retrieved_task = await db_store_parameterized.get(
+        'nonexistent-task-id', TEST_CONTEXT
+    )
+    assert retrieved_task is None
+
+
+@pytest.mark.asyncio
+async def test_delete_task(db_store_parameterized: DatabaseTaskStore) -> None:
+    """Test deleting a task from the DatabaseTaskStore."""
+    task_id = f'delete-test-task-{db_store_parameterized.engine.url.drivername}'
+    task_to_save_and_delete = Task()
+    task_to_save_and_delete.CopyFrom(MINIMAL_TASK_OBJ)
+    task_to_save_and_delete.id = task_id
+    await db_store_parameterized.save(task_to_save_and_delete, TEST_CONTEXT)
+
+    assert (
+        await db_store_parameterized.get(
+            task_to_save_and_delete.id, TEST_CONTEXT
+        )
+        is not None
+    )
+    await db_store_parameterized.delete(
+        task_to_save_and_delete.id, TEST_CONTEXT
+    )
+    assert (
+        await db_store_parameterized.get(
+            task_to_save_and_delete.id, TEST_CONTEXT
+        )
+        is None
+    )
+
+
+@pytest.mark.asyncio
+async def test_delete_nonexistent_task(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test deleting a nonexistent task. Should not error."""
+    await db_store_parameterized.delete(
+        'nonexistent-delete-task-id', TEST_CONTEXT
+    )
+
+
+@pytest.mark.asyncio
+async def test_save_and_get_detailed_task(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test saving and retrieving a task with more fields populated."""
+    task_id = f'detailed-task-{db_store_parameterized.engine.url.drivername}'
+    test_timestamp = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+    test_task = Task(
+        id=task_id,
+        context_id='test-session-1',
+        status=TaskStatus(
+            state=TaskState.TASK_STATE_WORKING, timestamp=test_timestamp
+        ),
+        metadata={'key1': 'value1', 'key2': 123},
+        artifacts=[
+            Artifact(
+                artifact_id='artifact-1',
+                parts=[Part(text='hello')],
+            )
+        ],
+        history=[
+            Message(
+                message_id='msg-1',
+                role=Role.ROLE_USER,
+                parts=[Part(text='user input')],
+            )
+        ],
+    )
+
+    await db_store_parameterized.save(test_task, TEST_CONTEXT)
+    retrieved_task = await db_store_parameterized.get(
+        test_task.id, TEST_CONTEXT
+    )
+
+    assert retrieved_task is not None
+    assert retrieved_task.id == test_task.id
+    assert retrieved_task.context_id == test_task.context_id
+    assert retrieved_task.status.state == TaskState.TASK_STATE_WORKING
+    # Compare timestamps - proto Timestamp has ToDatetime() method
+    assert (
+        retrieved_task.status.timestamp.ToDatetime()
+        == test_timestamp.replace(tzinfo=None)
+    )
+    assert dict(retrieved_task.metadata) == {'key1': 'value1', 'key2': 123}
+
+    # Use MessageToDict for proto serialization comparisons
+    assert (
+        MessageToDict(retrieved_task)['artifacts']
+        == MessageToDict(test_task)['artifacts']
+    )
+    assert (
+        MessageToDict(retrieved_task)['history']
+        == MessageToDict(test_task)['history']
+    )
+
+    await db_store_parameterized.delete(test_task.id, TEST_CONTEXT)
+    assert await db_store_parameterized.get(test_task.id, TEST_CONTEXT) is None
+
+
+@pytest.mark.asyncio
+async def test_update_task(db_store_parameterized: DatabaseTaskStore) -> None:
+    """Test updating an existing task."""
+    task_id = f'update-test-task-{db_store_parameterized.engine.url.drivername}'
+    original_timestamp = datetime(2023, 1, 2, 10, 0, 0, tzinfo=timezone.utc)
+    original_task = Task(
+        id=task_id,
+        context_id='session-update',
+        status=TaskStatus(
+            state=TaskState.TASK_STATE_SUBMITTED, timestamp=original_timestamp
+        ),
+        # Proto metadata is a Struct, can't be None - leave empty
+        artifacts=[],
+        history=[],
+    )
+    await db_store_parameterized.save(original_task, TEST_CONTEXT)
+
+    retrieved_before_update = await db_store_parameterized.get(
+        task_id, TEST_CONTEXT
+    )
+    assert retrieved_before_update is not None
+    assert (
+        retrieved_before_update.status.state == TaskState.TASK_STATE_SUBMITTED
+    )
+    assert (
+        len(retrieved_before_update.metadata) == 0
+    )  # Proto map is empty, not None
+
+    updated_timestamp = datetime(2023, 1, 2, 11, 0, 0, tzinfo=timezone.utc)
+    updated_task = Task()
+    updated_task.CopyFrom(original_task)
+    updated_task.status.state = TaskState.TASK_STATE_COMPLETED
+    updated_task.status.timestamp.FromDatetime(updated_timestamp)
+    updated_task.metadata['update_key'] = 'update_value'
+
+    await db_store_parameterized.save(updated_task, TEST_CONTEXT)
+
+    retrieved_after_update = await db_store_parameterized.get(
+        task_id, TEST_CONTEXT
+    )
+    assert retrieved_after_update is not None
+    assert retrieved_after_update.status.state == TaskState.TASK_STATE_COMPLETED
+    assert dict(retrieved_after_update.metadata) == {
+        'update_key': 'update_value'
+    }
+
+    await db_store_parameterized.delete(task_id, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_metadata_field_mapping(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test that metadata field is correctly mapped between Proto and SQLAlchemy.
+
+    This test verifies:
+    1. Metadata can be empty (proto Struct can't be None)
+    2. Metadata can be a simple dict
+    3. Metadata can contain nested structures
+    4. Metadata is correctly saved and retrieved
+    5. The mapping between task.metadata and task_metadata column works
+    """
+    # Test 1: Task with no metadata (empty Struct in proto)
+    task_no_metadata = Task(
+        id='task-metadata-test-1',
+        context_id='session-meta-1',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+    await db_store_parameterized.save(task_no_metadata, TEST_CONTEXT)
+    retrieved_no_metadata = await db_store_parameterized.get(
+        'task-metadata-test-1', TEST_CONTEXT
+    )
+    assert retrieved_no_metadata is not None
+    # Proto Struct is empty, not None
+    assert len(retrieved_no_metadata.metadata) == 0
+
+    # Test 2: Task with simple metadata
+    simple_metadata = {'key': 'value', 'number': 42, 'boolean': True}
+    task_simple_metadata = Task(
+        id='task-metadata-test-2',
+        context_id='session-meta-2',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        metadata=simple_metadata,
+    )
+    await db_store_parameterized.save(task_simple_metadata, TEST_CONTEXT)
+    retrieved_simple = await db_store_parameterized.get(
+        'task-metadata-test-2', TEST_CONTEXT
+    )
+    assert retrieved_simple is not None
+    assert dict(retrieved_simple.metadata) == simple_metadata
+
+    # Test 3: Task with complex nested metadata
+    complex_metadata = {
+        'level1': {
+            'level2': {
+                'level3': ['a', 'b', 'c'],
+                'numeric': 3.14159,
+            },
+            'array': [1, 2, {'nested': 'value'}],
+        },
+        'special_chars': 'Hello\nWorld\t!',
+        'unicode': '🚀 Unicode test 你好',
+    }
+    task_complex_metadata = Task(
+        id='task-metadata-test-3',
+        context_id='session-meta-3',
+        status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        metadata=complex_metadata,
+    )
+    await db_store_parameterized.save(task_complex_metadata, TEST_CONTEXT)
+    retrieved_complex = await db_store_parameterized.get(
+        'task-metadata-test-3', TEST_CONTEXT
+    )
+    assert retrieved_complex is not None
+    # Convert proto Struct to dict for comparison
+    retrieved_meta = MessageToDict(retrieved_complex.metadata)
+    assert retrieved_meta == complex_metadata
+
+    # Test 4: Update metadata from empty to dict
+    task_update_metadata = Task(
+        id='task-metadata-test-4',
+        context_id='session-meta-4',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+    await db_store_parameterized.save(task_update_metadata, TEST_CONTEXT)
+
+    # Update metadata
+    task_update_metadata.metadata['updated'] = True
+    task_update_metadata.metadata['timestamp'] = '2024-01-01'
+    await db_store_parameterized.save(task_update_metadata, TEST_CONTEXT)
+
+    retrieved_updated = await db_store_parameterized.get(
+        'task-metadata-test-4', TEST_CONTEXT
+    )
+    assert retrieved_updated is not None
+    assert dict(retrieved_updated.metadata) == {
+        'updated': True,
+        'timestamp': '2024-01-01',
+    }
+
+    # Test 5: Clear metadata (set to empty)
+    task_update_metadata.metadata.Clear()
+    await db_store_parameterized.save(task_update_metadata, TEST_CONTEXT)
+
+    retrieved_none = await db_store_parameterized.get(
+        'task-metadata-test-4', TEST_CONTEXT
+    )
+    assert retrieved_none is not None
+    assert len(retrieved_none.metadata) == 0
+
+    # Cleanup
+    await db_store_parameterized.delete('task-metadata-test-1', TEST_CONTEXT)
+    await db_store_parameterized.delete('task-metadata-test-2', TEST_CONTEXT)
+    await db_store_parameterized.delete('task-metadata-test-3', TEST_CONTEXT)
+    await db_store_parameterized.delete('task-metadata-test-4', TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_owner_resource_scoping(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test that operations are scoped to the correct owner."""
+    task_store = db_store_parameterized
+
+    context_user1 = ServerCallContext(user=SampleUser(user_name='user1'))
+    context_user2 = ServerCallContext(user=SampleUser(user_name='user2'))
+    context_user3 = ServerCallContext(
+        user=SampleUser(user_name='user3')
+    )  # user with no tasks
+
+    # Create tasks for different owners
+    task1_user1, task2_user1, task1_user2 = Task(), Task(), Task()
+    task1_user1.CopyFrom(MINIMAL_TASK_OBJ)
+    task1_user1.id = 'u1-task1'
+    task2_user1.CopyFrom(MINIMAL_TASK_OBJ)
+    task2_user1.id = 'u1-task2'
+    task1_user2.CopyFrom(MINIMAL_TASK_OBJ)
+    task1_user2.id = 'u2-task1'
+
+    await task_store.save(task1_user1, context_user1)
+    await task_store.save(task2_user1, context_user1)
+    await task_store.save(task1_user2, context_user2)
+
+    # Test GET
+    assert await task_store.get('u1-task1', context_user1) is not None
+    assert await task_store.get('u1-task1', context_user2) is None
+    assert await task_store.get('u2-task1', context_user1) is None
+    assert await task_store.get('u2-task1', context_user2) is not None
+
+    # Test LIST
+    params = ListTasksRequest()
+    page_user1 = await task_store.list(params, context_user1)
+    assert len(page_user1.tasks) == 2
+    assert {t.id for t in page_user1.tasks} == {'u1-task1', 'u1-task2'}
+    assert page_user1.total_size == 2
+
+    page_user2 = await task_store.list(params, context_user2)
+    assert len(page_user2.tasks) == 1
+    assert {t.id for t in page_user2.tasks} == {'u2-task1'}
+    assert page_user2.total_size == 1
+
+    page_user3 = await task_store.list(params, context_user3)
+    assert len(page_user3.tasks) == 0
+    assert page_user3.total_size == 0
+
+    # Test DELETE
+    await task_store.delete('u1-task1', context_user2)  # Should not delete
+    assert await task_store.get('u1-task1', context_user1) is not None
+
+    await task_store.delete('u1-task1', context_user1)  # Should delete
+    assert await task_store.get('u1-task1', context_user1) is None
+
+    # Cleanup remaining tasks
+    await task_store.delete('u1-task2', context_user1)
+    await task_store.delete('u2-task1', context_user2)
+
+
+@pytest.mark.asyncio
+async def test_get_0_3_task_detailed(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test retrieving a detailed legacy v0.3 task from the database.
+
+    This test simulates a database that already contains legacy v0.3 JSON data
+    (string-based enums, different field names) and verifies that the store
+    correctly converts it to the modern Protobuf-based Task model.
+    """
+
+    task_id = 'legacy-detailed-1'
+    owner = 'legacy_user'
+    context_user = ServerCallContext(user=SampleUser(user_name=owner))
+
+    # 1. Create a detailed legacy Task using v0.3 models
+    legacy_task = types_v03.Task(
+        id=task_id,
+        context_id='legacy-ctx-1',
+        status=types_v03.TaskStatus(
+            state=types_v03.TaskState.working,
+            message=types_v03.Message(
+                message_id='msg-status',
+                role=types_v03.Role.agent,
+                parts=[
+                    types_v03.Part(
+                        root=types_v03.TextPart(text='Legacy status message')
+                    )
+                ],
+            ),
+            timestamp='2023-10-27T10:00:00Z',
+        ),
+        history=[
+            types_v03.Message(
+                message_id='msg-1',
+                role=types_v03.Role.user,
+                parts=[
+                    types_v03.Part(root=types_v03.TextPart(text='Hello legacy'))
+                ],
+            ),
+            types_v03.Message(
+                message_id='msg-2',
+                role=types_v03.Role.agent,
+                parts=[
+                    types_v03.Part(
+                        root=types_v03.DataPart(data={'legacy_key': 'value'})
+                    )
+                ],
+            ),
+        ],
+        artifacts=[
+            types_v03.Artifact(
+                artifact_id='art-1',
+                name='Legacy Artifact',
+                parts=[
+                    types_v03.Part(
+                        root=types_v03.FilePart(
+                            file=types_v03.FileWithUri(
+                                uri='https://example.com/legacy.txt',
+                                mime_type='text/plain',
+                            )
+                        )
+                    )
+                ],
+            )
+        ],
+        metadata={'meta_key': 'meta_val'},
+    )
+
+    # 2. Manually insert the legacy data into the database
+    # We must bypass the store's save() method because it expects Protobuf objects.
+    async with db_store_parameterized.async_session_maker.begin() as session:
+        # Pydantic model_dump(mode='json') produces exactly what would be in the legacy DB
+        legacy_data = legacy_task.model_dump(mode='json')
+
+        stmt = insert(db_store_parameterized.task_model).values(
+            id=task_id,
+            context_id=legacy_task.context_id,
+            owner=owner,
+            status=legacy_data['status'],
+            history=legacy_data['history'],
+            artifacts=legacy_data['artifacts'],
+            task_metadata=legacy_data['metadata'],
+            kind='task',
+            last_updated=None,
+        )
+        await session.execute(stmt)
+
+    # 3. Retrieve the task using the standard store.get()
+    # This will trigger conversion from legacy to 1.0 format in the _from_orm method
+    retrieved_task = await db_store_parameterized.get(task_id, context_user)
+
+    # 4. Verify the conversion to modern Protobuf
+    assert retrieved_task is not None
+    assert retrieved_task.id == task_id
+    assert retrieved_task.context_id == 'legacy-ctx-1'
+
+    # Check Status & State (The most critical part: string 'working' -> enum TASK_STATE_WORKING)
+    assert retrieved_task.status.state == TaskState.TASK_STATE_WORKING
+    assert retrieved_task.status.message.message_id == 'msg-status'
+    assert retrieved_task.status.message.role == Role.ROLE_AGENT
+    assert (
+        retrieved_task.status.message.parts[0].text == 'Legacy status message'
+    )
+
+    # Check History
+    assert len(retrieved_task.history) == 2
+    assert retrieved_task.history[0].message_id == 'msg-1'
+    assert retrieved_task.history[0].role == Role.ROLE_USER
+    assert retrieved_task.history[0].parts[0].text == 'Hello legacy'
+
+    assert retrieved_task.history[1].message_id == 'msg-2'
+    assert retrieved_task.history[1].role == Role.ROLE_AGENT
+    assert (
+        MessageToDict(retrieved_task.history[1].parts[0].data)['legacy_key']
+        == 'value'
+    )
+
+    # Check Artifacts
+    assert len(retrieved_task.artifacts) == 1
+    assert retrieved_task.artifacts[0].artifact_id == 'art-1'
+    assert retrieved_task.artifacts[0].name == 'Legacy Artifact'
+    assert (
+        retrieved_task.artifacts[0].parts[0].url
+        == 'https://example.com/legacy.txt'
+    )
+
+    # Check Metadata
+    assert dict(retrieved_task.metadata) == {'meta_key': 'meta_val'}
+
+    retrieved_tasks = await db_store_parameterized.list(
+        ListTasksRequest(), context_user
+    )
+    assert retrieved_tasks is not None
+    assert retrieved_tasks.tasks == [retrieved_task]
+
+    await db_store_parameterized.delete(task_id, context_user)
+
+
+@pytest.mark.asyncio
+async def test_custom_conversion():
+    engine = MagicMock()
+    # Custom callables
+    mock_to_orm = MagicMock(
+        return_value=TaskModel(id='custom_id', protocol_version='custom')
+    )
+    mock_from_orm = MagicMock(return_value=Task(id='custom_id'))
+    store = DatabaseTaskStore(
+        engine=engine,
+        core_to_model_conversion=mock_to_orm,
+        model_to_core_conversion=mock_from_orm,
+    )
+
+    task = Task(id='123')
+    model = store._to_orm(task, 'owner')
+    assert model.id == 'custom_id'
+    mock_to_orm.assert_called_once_with(task, 'owner')
+    model_instance = TaskModel(id='dummy')
+    loaded_task = store._from_orm(model_instance)
+    assert loaded_task.id == 'custom_id'
+    mock_from_orm.assert_called_once_with(model_instance)
+
+
+@pytest.mark.asyncio
+async def test_core_to_0_3_model_conversion(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    """Test storing and retrieving tasks in v0.3 format using conversion utilities.
+
+    Tests both class-level and instance-level assignment of the conversion function.
+    Setting the model_to_core_conversion class variables to compat_task_model_to_core would be redundant
+    as it is always called when retrieving 0.3 tasks.
+    """
+    store = db_store_parameterized
+
+    # Set the v0.3 persistence utilities
+    store.core_to_model_conversion = core_to_compat_task_model
+    task_id = 'v03-persistence-task'
+    original_task = Task(
+        id=task_id,
+        context_id='v03-context',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        metadata={'key': 'value'},
+    )
+
+    # 1. Save the task (will use core_to_compat_task_model)
+    await store.save(original_task, TEST_CONTEXT)
+
+    # 2. Verify it's stored in v0.3 format directly in DB
+    async with store.async_session_maker() as session:
+        db_task = await session.get(TaskModel, task_id)
+        assert db_task is not None
+        assert db_task.protocol_version == '0.3'
+        # v0.3 status JSON uses string for state
+        assert isinstance(db_task.status, dict)
+        assert db_task.status['state'] == 'working'
+
+    # 3. Retrieve the task (will use compat_task_model_to_core)
+    retrieved_task = await store.get(task_id, context=TEST_CONTEXT)
+    assert retrieved_task is not None
+    assert retrieved_task.id == original_task.id
+    assert retrieved_task.status.state == TaskState.TASK_STATE_WORKING
+    assert dict(retrieved_task.metadata) == {'key': 'value'}
+    # Reset conversion attributes
+    store.core_to_model_conversion = None
+    await store.delete('v03-persistence-task', TEST_CONTEXT)
+
+
+def _task(task_id: str, seconds: int | None) -> Task:
+    task = Task(
+        id=task_id,
+        context_id='ctx',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+    )
+    if seconds is not None:
+        task.status.timestamp.FromSeconds(seconds)
+    return task
+
+
+async def _list_all(store: DatabaseTaskStore, page_size: int) -> list[str]:
+    seen: list[str] = []
+    params = ListTasksRequest(page_size=page_size)
+    while True:
+        page = await store.list(params, TEST_CONTEXT)
+        seen.extend(task.id for task in page.tasks)
+        if not page.next_page_token:
+            return seen
+        params.page_token = page.next_page_token
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'change, task_id, expected_second_page',
+    [
+        # The last task returned moves to the top: the listing continues.
+        ('update', 't4', ['t3', 't2']),
+        # The next task moves above the cursor: skipped this pass, no repeats.
+        ('update', 't3', ['t2', 't1']),
+        # Deleting either task does not invalidate the token.
+        ('delete', 't4', ['t3', 't2']),
+        ('delete', 't3', ['t2', 't1']),
+    ],
+)
+async def test_list_tasks_page_token_survives_task_changes(
+    db_store_parameterized: DatabaseTaskStore,
+    change: str,
+    task_id: str,
+    expected_second_page: list[str],
+) -> None:
+    """Regression test for #1280: the token is a position, not a task lookup."""
+    store = db_store_parameterized
+    for i in range(1, 6):
+        await store.save(_task(f't{i}', 1_700_000_000 + i), TEST_CONTEXT)
+    first = await store.list(ListTasksRequest(page_size=2), TEST_CONTEXT)
+    assert [task.id for task in first.tasks] == ['t5', 't4']
+
+    if change == 'update':
+        await store.save(_task(task_id, 1_800_000_000), TEST_CONTEXT)
+    else:
+        await store.delete(task_id, TEST_CONTEXT)
+    second = await store.list(
+        ListTasksRequest(page_size=2, page_token=first.next_page_token),
+        TEST_CONTEXT,
+    )
+
+    assert [task.id for task in second.tasks] == expected_second_page
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('page_size', [1, 2, 20])
+async def test_list_tasks_pages_through_ties_and_missing_timestamps(
+    db_store_parameterized: DatabaseTaskStore, page_size: int
+) -> None:
+    """Equal timestamps (as on second-precision backends) and missing ones."""
+    store = db_store_parameterized
+    for task in (
+        _task('a', 1_700_000_000),
+        _task('b', 1_700_000_000),
+        _task('c', 1_700_000_000),
+        _task('newest', 1_700_000_100),
+        _task('undated-a', None),
+        _task('undated-b', None),
+    ):
+        await store.save(task, TEST_CONTEXT)
+
+    assert await _list_all(store, page_size) == [
+        'newest',
+        'c',
+        'b',
+        'a',
+        'undated-b',
+        'undated-a',
+    ]
+
+
+@pytest.mark.asyncio
+async def test_list_tasks_rejects_malformed_cursor_token(
+    db_store_parameterized: DatabaseTaskStore,
+) -> None:
+    token = urlsafe_b64encode(b'{"ts":"soon","id":"t1"}').decode().rstrip('=')
+
+    with pytest.raises(InvalidParamsError):
+        await db_store_parameterized.list(
+            ListTasksRequest(page_size=2, page_token=token), TEST_CONTEXT
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'timestamp_ns',
+    [
+        pytest.param(-62_135_596_800_000_000_001, id='before-min-timestamp'),
+        pytest.param(253_402_300_800_000_000_000, id='after-max-timestamp'),
+        pytest.param(-(10**100), id='huge-negative'),
+        pytest.param(10**100, id='huge-positive'),
+    ],
+)
+async def test_list_tasks_rejects_out_of_range_cursor_timestamp(
+    db_store_parameterized: DatabaseTaskStore, timestamp_ns: int
+) -> None:
+    token = encode_list_tasks_cursor(
+        ListTasksCursor(timestamp_ns=timestamp_ns, task_id='t1')
+    )
+
+    with pytest.raises(InvalidParamsError, match='Invalid page token'):
+        await db_store_parameterized.list(
+            ListTasksRequest(page_size=2, page_token=token), TEST_CONTEXT
+        )
+
+
+# Ensure aiosqlite, asyncpg, and aiomysql are installed in the test environment (added to pyproject.toml).
diff --git a/tests/server/tasks/test_id_generator.py b/tests/server/tasks/test_id_generator.py
new file mode 100644
index 000000000..19ca40fad
--- /dev/null
+++ b/tests/server/tasks/test_id_generator.py
@@ -0,0 +1,130 @@
+import uuid
+
+import pytest
+
+from a2a.server.id_generator import (
+    IDGenerator,
+    IDGeneratorContext,
+    UUIDGenerator,
+)
+from pydantic import ValidationError
+
+
+class TestIDGeneratorContext:
+    """Tests for IDGeneratorContext."""
+
+    def test_context_creation_with_all_fields(self):
+        """Test creating context with all fields populated."""
+        context = IDGeneratorContext(
+            task_id='task_123', context_id='context_456'
+        )
+        assert context.task_id == 'task_123'
+        assert context.context_id == 'context_456'
+
+    def test_context_creation_with_defaults(self):
+        """Test creating context with default None values."""
+        context = IDGeneratorContext()
+        assert context.task_id is None
+        assert context.context_id is None
+
+    @pytest.mark.parametrize(
+        'kwargs, expected_task_id, expected_context_id',
+        [
+            ({'task_id': 'task_123'}, 'task_123', None),
+            ({'context_id': 'context_456'}, None, 'context_456'),
+        ],
+    )
+    def test_context_creation_with_partial_fields(
+        self, kwargs, expected_task_id, expected_context_id
+    ):
+        """Test creating context with only some fields populated."""
+        context = IDGeneratorContext(**kwargs)
+        assert context.task_id == expected_task_id
+        assert context.context_id == expected_context_id
+
+    def test_context_mutability(self):
+        """Test that context fields can be updated (Pydantic models are mutable by default)."""
+        context = IDGeneratorContext(task_id='task_123')
+        context.task_id = 'task_456'
+        assert context.task_id == 'task_456'
+
+    def test_context_validation(self):
+        """Test that context raises validation error for invalid types."""
+        with pytest.raises(ValidationError):
+            IDGeneratorContext(task_id={'not': 'a string'})  # type: ignore[arg-type]
+
+
+class TestIDGenerator:
+    """Tests for IDGenerator abstract base class."""
+
+    def test_cannot_instantiate_abstract_class(self):
+        """Test that IDGenerator cannot be instantiated directly."""
+        with pytest.raises(TypeError):
+            IDGenerator()  # type: ignore[abstract]
+
+    def test_subclass_must_implement_generate(self):
+        """Test that subclasses must implement the generate method."""
+
+        class IncompleteGenerator(IDGenerator):
+            pass
+
+        with pytest.raises(TypeError):
+            IncompleteGenerator()  # type: ignore[abstract]
+
+    def test_valid_subclass_implementation(self):
+        """Test that a valid subclass can be instantiated."""
+
+        class ValidGenerator(IDGenerator):  # pylint: disable=C0115,R0903
+            def generate(self, context: IDGeneratorContext) -> str:
+                return 'test_id'
+
+        generator = ValidGenerator()
+        assert generator.generate(IDGeneratorContext()) == 'test_id'
+
+
+@pytest.fixture
+def generator():
+    """Returns a UUIDGenerator instance."""
+    return UUIDGenerator()
+
+
+@pytest.fixture
+def context():
+    """Returns a IDGeneratorContext instance."""
+    return IDGeneratorContext()
+
+
+class TestUUIDGenerator:
+    """Tests for UUIDGenerator implementation."""
+
+    def test_generate_returns_string(self, generator, context):
+        """Test that generate returns a valid v4 UUID string."""
+        result = generator.generate(context)
+        assert isinstance(result, str)
+        parsed_uuid = uuid.UUID(result)
+        assert parsed_uuid.version == 4
+
+    def test_generate_produces_unique_ids(self, generator, context):
+        """Test that multiple calls produce unique IDs."""
+        ids = [generator.generate(context) for _ in range(100)]
+        # All IDs should be unique
+        assert len(ids) == len(set(ids))
+
+    @pytest.mark.parametrize(
+        'context_arg',
+        [
+            None,
+            IDGeneratorContext(),
+        ],
+        ids=[
+            'none_context',
+            'empty_context',
+        ],
+    )
+    def test_generate_works_with_various_contexts(self, context_arg):
+        """Test that generate works with various context inputs."""
+        generator = UUIDGenerator()
+        result = generator.generate(context_arg)
+        assert isinstance(result, str)
+        parsed_uuid = uuid.UUID(result)
+        assert parsed_uuid.version == 4
diff --git a/tests/server/tasks/test_inmemory_push_notifications.py b/tests/server/tasks/test_inmemory_push_notifications.py
new file mode 100644
index 000000000..8acae7d9d
--- /dev/null
+++ b/tests/server/tasks/test_inmemory_push_notifications.py
@@ -0,0 +1,688 @@
+import asyncio
+import concurrent.futures
+import threading
+import unittest
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+
+from a2a.auth.user import User
+from a2a.server.context import ServerCallContext
+from a2a.server.tasks.base_push_notification_sender import (
+    BasePushNotificationSender,
+)
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.types.a2a_pb2 import (
+    StreamResponse,
+    Task,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+from google.protobuf.json_format import MessageToDict
+
+
+# Suppress logging for cleaner test output, can be enabled for debugging
+# logging.disable(logging.CRITICAL)
+
+
+def _create_sample_task(
+    task_id: str = 'task123',
+    status_state: TaskState = TaskState.TASK_STATE_COMPLETED,
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id='ctx456',
+        status=TaskStatus(state=status_state),
+    )
+
+
+def _create_sample_push_config(
+    url: str = 'http://example.com/callback',
+    config_id: str = 'cfg1',
+    token: str | None = None,
+    task_id: str = '',
+) -> TaskPushNotificationConfig:
+    return TaskPushNotificationConfig(
+        id=config_id, url=url, token=token, task_id=task_id
+    )
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+MINIMAL_CALL_CONTEXT = ServerCallContext(user=SampleUser(user_name='user'))
+
+
+def _lock_is_owned(lock: threading.RLock) -> bool:
+    is_owned = getattr(lock, '_is_owned', None)
+    return bool(is_owned()) if callable(is_owned) else False
+
+
+def _set_info_in_thread(
+    store: InMemoryPushNotificationConfigStore,
+    task_id: str,
+    config_id: str,
+    context: ServerCallContext,
+) -> None:
+    asyncio.run(
+        store.set_info(
+            task_id,
+            _create_sample_push_config(
+                url=f'http://example.com/{config_id}',
+                config_id=config_id,
+            ),
+            context,
+        )
+    )
+
+
+class TestInMemoryPushNotifier(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        self.mock_httpx_client = AsyncMock(spec=httpx.AsyncClient)
+        self.config_store = InMemoryPushNotificationConfigStore()
+        self.notifier = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.config_store,
+        )
+
+    def test_constructor_stores_client(self) -> None:
+        self.assertEqual(self.notifier._client, self.mock_httpx_client)
+
+    async def test_set_info_adds_new_config(self) -> None:
+        task_id = 'task_new'
+        config = _create_sample_push_config(
+            task_id=task_id, url='http://new.url/callback'
+        )
+
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(retrieved, [config])
+
+    async def test_set_info_returns_the_stored_config_without_mutating_input(
+        self,
+    ) -> None:
+        task_id = 'task_normalize'
+        config = TaskPushNotificationConfig(url='http://normalize.url/callback')
+
+        stored = await self.config_store.set_info(
+            task_id, config, MINIMAL_CALL_CONTEXT
+        )
+
+        assert (stored.task_id, stored.id) == (task_id, task_id)
+        assert (config.task_id, config.id) == ('', '')
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(retrieved, [stored])
+
+    async def test_set_info_appends_to_existing_config(self) -> None:
+        task_id = 'task_update'
+        initial_config = _create_sample_push_config(
+            task_id=task_id,
+            url='http://initial.url/callback',
+            config_id='cfg_initial',
+        )
+        await self.config_store.set_info(
+            task_id, initial_config, MINIMAL_CALL_CONTEXT
+        )
+
+        updated_config = _create_sample_push_config(
+            task_id=task_id,
+            url='http://updated.url/callback',
+            config_id='cfg_updated',
+        )
+        await self.config_store.set_info(
+            task_id, updated_config, MINIMAL_CALL_CONTEXT
+        )
+
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(len(retrieved), 2)
+        self.assertEqual(retrieved[0], initial_config)
+        self.assertEqual(retrieved[1], updated_config)
+
+    async def test_set_info_without_config_id(self) -> None:
+        task_id = 'task1'
+        initial_config = TaskPushNotificationConfig(
+            url='http://initial.url/callback'
+        )
+        await self.config_store.set_info(
+            task_id, initial_config, MINIMAL_CALL_CONTEXT
+        )
+
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        assert retrieved[0].id == task_id
+
+        updated_config = TaskPushNotificationConfig(
+            url='http://initial.url/callback_new'
+        )
+        await self.config_store.set_info(
+            task_id, updated_config, MINIMAL_CALL_CONTEXT
+        )
+
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        assert len(retrieved) == 1
+        self.assertEqual(retrieved[0].url, updated_config.url)
+
+    async def test_get_info_existing_config(self) -> None:
+        task_id = 'task_get_exist'
+        config = _create_sample_push_config(
+            task_id=task_id, url='http://get.this/callback'
+        )
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        retrieved_config = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(retrieved_config, [config])
+
+    async def test_get_info_non_existent_config(self) -> None:
+        task_id = 'task_get_non_exist'
+        retrieved_config = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        assert retrieved_config == []
+
+    async def test_delete_info_existing_config(self) -> None:
+        task_id = 'task_delete_exist'
+        config = _create_sample_push_config(url='http://delete.this/callback')
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(len(retrieved), 1)
+
+        await self.config_store.delete_info(
+            task_id, config_id=config.id, context=MINIMAL_CALL_CONTEXT
+        )
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(len(retrieved), 0)
+
+    async def test_delete_info_non_existent_config(self) -> None:
+        task_id = 'task_delete_non_exist'
+        # Ensure it doesn't raise an error
+        try:
+            await self.config_store.delete_info(
+                task_id, context=MINIMAL_CALL_CONTEXT
+            )
+        except Exception as e:
+            self.fail(
+                f'delete_info raised {e} unexpectedly for nonexistent task_id'
+            )
+        retrieved = await self.config_store.get_info(
+            task_id, MINIMAL_CALL_CONTEXT
+        )
+        self.assertEqual(len(retrieved), 0)
+
+    async def test_send_notification_success(self) -> None:
+        task_id = 'task_send_success'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/here')
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        # Mock the post call to simulate success
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_awaited_once()
+        called_args, called_kwargs = self.mock_httpx_client.post.call_args
+        self.assertEqual(called_args[0], config.url)
+        self.assertEqual(
+            called_kwargs['json'],
+            MessageToDict(StreamResponse(task=task_data)),
+        )
+        self.assertNotIn(
+            'auth', called_kwargs
+        )  # auth is not passed by current implementation
+        mock_response.raise_for_status.assert_called_once()
+
+    async def test_send_notification_with_token_success(self) -> None:
+        task_id = 'task_send_success'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(
+            url='http://notify.me/here', token='unique_token'
+        )
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        # Mock the post call to simulate success
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_awaited_once()
+        called_args, called_kwargs = self.mock_httpx_client.post.call_args
+        self.assertEqual(called_args[0], config.url)
+        self.assertEqual(
+            called_kwargs['json'],
+            MessageToDict(StreamResponse(task=task_data)),
+        )
+        self.assertEqual(
+            called_kwargs['headers'],
+            {'X-A2A-Notification-Token': 'unique_token'},
+        )
+        self.assertNotIn(
+            'auth', called_kwargs
+        )  # auth is not passed by current implementation
+        mock_response.raise_for_status.assert_called_once()
+
+    async def test_send_notification_no_config(self) -> None:
+        task_id = 'task_send_no_config'
+        task_data = _create_sample_task(task_id=task_id)
+
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_not_called()
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_send_notification_http_status_error(
+        self, mock_logger: MagicMock
+    ) -> None:
+        task_id = 'task_send_http_err'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/http_error')
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        mock_response = MagicMock(
+            spec=httpx.Response
+        )  # Use MagicMock for status_code attribute
+        mock_response.status_code = 404
+        mock_response.text = 'Not Found'
+        http_error = httpx.HTTPStatusError(
+            'Not Found', request=MagicMock(), response=mock_response
+        )
+        self.mock_httpx_client.post.side_effect = http_error
+
+        # The method should catch the error and log it, not re-raise
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_awaited_once()
+        mock_logger.exception.assert_called_once()
+        # Check that the error message contains the generic part and the specific exception string
+        self.assertIn(
+            'Error sending push-notification',
+            mock_logger.exception.call_args[0][0],
+        )
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_send_notification_request_error(
+        self, mock_logger: MagicMock
+    ) -> None:
+        task_id = 'task_send_req_err'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/req_error')
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        request_error = httpx.RequestError('Network issue', request=MagicMock())
+        self.mock_httpx_client.post.side_effect = request_error
+
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_awaited_once()
+        mock_logger.exception.assert_called_once()
+        self.assertIn(
+            'Error sending push-notification',
+            mock_logger.exception.call_args[0][0],
+        )
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_send_notification_with_auth(
+        self, mock_logger: MagicMock
+    ) -> None:
+        """Test that auth field is not used by current implementation.
+
+        The current BasePushNotificationSender only supports token-based auth,
+        not the authentication field. This test verifies that the notification
+        still works even if the config has an authentication field set.
+        """
+        task_id = 'task_send_auth'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/auth')
+        # The current implementation doesn't use the authentication field
+        # It only supports token-based auth via the token field
+        await self.config_store.set_info(task_id, config, MINIMAL_CALL_CONTEXT)
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.notifier.send_notification(task_id, task_data)
+
+        self.mock_httpx_client.post.assert_awaited_once()
+        called_args, called_kwargs = self.mock_httpx_client.post.call_args
+        self.assertEqual(called_args[0], config.url)
+        self.assertEqual(
+            called_kwargs['json'],
+            MessageToDict(StreamResponse(task=task_data)),
+        )
+        self.assertNotIn(
+            'auth', called_kwargs
+        )  # auth is not passed by current implementation
+        mock_response.raise_for_status.assert_called_once()
+
+    async def test_owner_resource_scoping(self) -> None:
+        """Test that operations are scoped to the correct owner."""
+        context_user1 = ServerCallContext(user=SampleUser(user_name='user1'))
+        context_user2 = ServerCallContext(user=SampleUser(user_name='user2'))
+
+        # Create configs for different owners
+        task1_u1_config1 = TaskPushNotificationConfig(
+            id='t1-u1-c1', url='http://u1.com/1'
+        )
+        task1_u1_config2 = TaskPushNotificationConfig(
+            id='t1-u1-c2', url='http://u1.com/2'
+        )
+        task1_u2_config1 = TaskPushNotificationConfig(
+            id='t1-u2-c1', url='http://u2.com/1'
+        )
+        task2_u1_config1 = TaskPushNotificationConfig(
+            id='t2-u1-c1', url='http://u1.com/3'
+        )
+
+        await self.config_store.set_info(
+            'task1', task1_u1_config1, context_user1
+        )
+        await self.config_store.set_info(
+            'task1', task1_u1_config2, context_user1
+        )
+        await self.config_store.set_info(
+            'task1', task1_u2_config1, context_user2
+        )
+        await self.config_store.set_info(
+            'task2', task2_u1_config1, context_user1
+        )
+
+        # Test GET_INFO
+        # User 1 should get only their configs for task1
+        u1_task1_configs = await self.config_store.get_info(
+            'task1', context_user1
+        )
+        self.assertEqual(len(u1_task1_configs), 2)
+        self.assertEqual(
+            {c.id for c in u1_task1_configs}, {'t1-u1-c1', 't1-u1-c2'}
+        )
+
+        # User 2 should get only their configs for task1
+        u2_task1_configs = await self.config_store.get_info(
+            'task1', context_user2
+        )
+        self.assertEqual(len(u2_task1_configs), 1)
+        self.assertEqual(u2_task1_configs[0].id, 't1-u2-c1')
+
+        # User 2 should get no configs for task2
+        u2_task2_configs = await self.config_store.get_info(
+            'task2', context_user2
+        )
+        self.assertEqual(len(u2_task2_configs), 0)
+
+        # User 1 should get their config for task2
+        u1_task2_configs = await self.config_store.get_info(
+            'task2', context_user1
+        )
+        self.assertEqual(len(u1_task2_configs), 1)
+        self.assertEqual(u1_task2_configs[0].id, 't2-u1-c1')
+
+        # Test DELETE_INFO
+        # User 2 deleting User 1's config should not work
+        await self.config_store.delete_info('task1', context_user2, 't1-u1-c1')
+        u1_task1_configs = await self.config_store.get_info(
+            'task1', context_user1
+        )
+        self.assertEqual(len(u1_task1_configs), 2)
+
+        # User 1 deleting their own config
+        await self.config_store.delete_info('task1', context_user1, 't1-u1-c1')
+        u1_task1_configs = await self.config_store.get_info(
+            'task1', context_user1
+        )
+        self.assertEqual(len(u1_task1_configs), 1)
+        self.assertEqual(u1_task1_configs[0].id, 't1-u1-c2')
+
+        # User 1 deleting all configs for task2
+        await self.config_store.delete_info('task2', context=context_user1)
+        u1_task2_configs = await self.config_store.get_info(
+            'task2', context_user1
+        )
+        self.assertEqual(len(u1_task2_configs), 0)
+
+        # Cleanup remaining
+        await self.config_store.delete_info('task1', context=context_user1)
+        await self.config_store.delete_info('task1', context=context_user2)
+
+    async def test_set_info_creates_owner_bucket_under_lock(self) -> None:
+        """Creating the first owner bucket must happen while the RLock is held."""
+        store = InMemoryPushNotificationConfigStore()
+        lock_held: list[bool] = []
+
+        class _LockHeldOwnerMap(
+            dict[str, dict[str, list[TaskPushNotificationConfig]]]
+        ):
+            def setdefault(
+                self,
+                key: str,
+                default: (
+                    dict[str, list[TaskPushNotificationConfig]] | None
+                ) = None,
+            ) -> dict[str, list[TaskPushNotificationConfig]]:
+                lock_held.append(_lock_is_owned(store.lock))
+                if default is None:
+                    default = {}
+                return super().setdefault(key, default)
+
+            def __setitem__(
+                self,
+                key: str,
+                value: dict[str, list[TaskPushNotificationConfig]],
+            ) -> None:
+                lock_held.append(_lock_is_owned(store.lock))
+                super().__setitem__(key, value)
+
+        store._push_notification_infos = _LockHeldOwnerMap()
+        await store.set_info(
+            'task-a',
+            _create_sample_push_config(config_id='cfg-a'),
+            MINIMAL_CALL_CONTEXT,
+        )
+        self.assertTrue(lock_held)
+        self.assertTrue(all(lock_held))
+
+    async def test_concurrent_first_owner_set_info_keeps_both(
+        self,
+    ) -> None:
+        """Concurrent first configs for a new owner must both persist."""
+        store = InMemoryPushNotificationConfigStore()
+        context = ServerCallContext(user=SampleUser(user_name='race-owner'))
+        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:
+            futures = [
+                pool.submit(
+                    _set_info_in_thread, store, 'task-a', 'cfg-a', context
+                ),
+                pool.submit(
+                    _set_info_in_thread, store, 'task-b', 'cfg-b', context
+                ),
+            ]
+            for future in futures:
+                future.result(timeout=10)
+
+        configs_a = await store.get_info('task-a', context)
+        configs_b = await store.get_info('task-b', context)
+        self.assertEqual([config.id for config in configs_a], ['cfg-a'])
+        self.assertEqual([config.id for config in configs_b], ['cfg-b'])
+
+
+class TestPushNotificationDispatchAcrossOwners(
+    unittest.IsolatedAsyncioTestCase
+):
+    """Dispatch-correctness tests for the registrar/dispatcher asymmetry.
+
+    Push notifications must fire for any event on the task, regardless of
+    which user's action triggered the event. The dispatch path therefore
+    reads configs via get_info_for_dispatch (cross-owner), not
+    get_info (owner-scoped).
+    """
+
+    def setUp(self) -> None:
+        self.mock_httpx_client = AsyncMock(spec=httpx.AsyncClient)
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        self.config_store = InMemoryPushNotificationConfigStore()
+
+        self.sender = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.config_store,
+        )
+
+    async def test_multi_registrar_fan_out(self) -> None:
+        """Three users registering distinct webhooks for the same task all fire."""
+        users_and_urls = [
+            ('alice', 'http://alice.example.com/cb', 'tok-alice'),
+            ('bob', 'http://bob.example.com/cb', 'tok-bob'),
+            ('carol', 'http://carol.example.com/cb', 'tok-carol'),
+        ]
+        for user_name, url, token in users_and_urls:
+            ctx = ServerCallContext(user=SampleUser(user_name=user_name))
+            cfg = TaskPushNotificationConfig(
+                id=f'cfg-{user_name}', url=url, token=token
+            )
+            await self.config_store.set_info('shared-task', cfg, ctx)
+
+        await self.sender.send_notification(
+            'shared-task', _create_sample_task(task_id='shared-task')
+        )
+
+        self.assertEqual(self.mock_httpx_client.post.await_count, 3)
+        called_urls = {
+            call.args[0] for call in self.mock_httpx_client.post.call_args_list
+        }
+        self.assertEqual(
+            called_urls,
+            {url for _, url, _ in users_and_urls},
+        )
+        called_tokens = {
+            call.kwargs['headers']['X-A2A-Notification-Token']
+            for call in self.mock_httpx_client.post.call_args_list
+        }
+        self.assertEqual(
+            called_tokens,
+            {token for _, _, token in users_and_urls},
+        )
+
+    async def test_write_side_owner_isolation_preserved(self) -> None:
+        """Bob's ``delete_info`` against Alice's config is a no-op.
+
+        After the no-op, Alice's config must still be:
+        (a) retrievable via the user-callable ``get_info`` for Alice, and
+        (b) returned by ``get_info_for_dispatch`` so that the
+            notification will still fire.
+
+        Guards the write-side scoping that the design preserves
+        (see §9.3).
+        """
+        alice_ctx = ServerCallContext(user=SampleUser(user_name='alice'))
+        bob_ctx = ServerCallContext(user=SampleUser(user_name='bob'))
+
+        config = TaskPushNotificationConfig(
+            id='alice-cfg',
+            url='http://alice.example.com/cb',
+            token='alice-token',
+        )
+        await self.config_store.set_info('shared-task', config, alice_ctx)
+
+        # Bob attempts to delete Alice's config -- must be a no-op.
+        await self.config_store.delete_info(
+            'shared-task', context=bob_ctx, config_id='alice-cfg'
+        )
+
+        # (a) Alice's user-callable view is unchanged.
+        alice_view = await self.config_store.get_info('shared-task', alice_ctx)
+        self.assertEqual(len(alice_view), 1)
+        self.assertEqual(alice_view[0].id, 'alice-cfg')
+
+        # (b) Dispatch path still sees the config (notifications fire).
+        dispatched = await self.config_store.get_info_for_dispatch(
+            'shared-task'
+        )
+        self.assertEqual(len(dispatched), 1)
+        self.assertEqual(dispatched[0].id, 'alice-cfg')
+        self.assertEqual(dispatched[0].token, 'alice-token')
+
+        # And end-to-end: the sender actually dispatches to Alice's URL.
+        await self.sender.send_notification(
+            'shared-task', _create_sample_task(task_id='shared-task')
+        )
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            'http://alice.example.com/cb',
+            json=MessageToDict(
+                StreamResponse(task=_create_sample_task(task_id='shared-task'))
+            ),
+            headers={'X-A2A-Notification-Token': 'alice-token'},
+        )
+
+    async def test_cross_user_dispatch_alice_registers_bob_triggers(
+        self,
+    ) -> None:
+        """Alice registers; Bob triggers; Alice's webhook receives the POST.
+
+        The send_notification carries no identity, so there is no notion of
+        "who triggered this event" at the store layer. get_info_for_dispatch
+        returns Alice's config because Alice registered it. The fact that the
+        event was caused by Bob is not visible to (and not relevant for) the
+        dispatch path.
+        """
+        alice_context = ServerCallContext(user=SampleUser(user_name='alice'))
+        config = _create_sample_push_config(
+            url='http://alice.example.com/cb', token='alice-token'
+        )
+        await self.config_store.set_info('collab-task', config, alice_context)
+
+        # No bob_context is passed anywhere -- the dispatch path never
+        # sees it. This is precisely the point: identity is not the
+        # dispatch path's concern.
+        await self.sender.send_notification(
+            'collab-task', _create_sample_task(task_id='collab-task')
+        )
+
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            'http://alice.example.com/cb',
+            json=MessageToDict(
+                StreamResponse(task=_create_sample_task(task_id='collab-task'))
+            ),
+            headers={'X-A2A-Notification-Token': 'alice-token'},
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/server/tasks/test_inmemory_task_store.py b/tests/server/tasks/test_inmemory_task_store.py
index 9eb8eae9c..40f9ecf8d 100644
--- a/tests/server/tasks/test_inmemory_task_store.py
+++ b/tests/server/tasks/test_inmemory_task_store.py
@@ -1,26 +1,72 @@
-from typing import Any
+import asyncio
+import concurrent.futures
+import threading
+
+from base64 import urlsafe_b64encode
+from datetime import datetime, timedelta, timezone
 
 import pytest
 
+from a2a.auth.user import User
+from a2a.server.context import ServerCallContext
 from a2a.server.tasks import InMemoryTaskStore
-from a2a.types import Task
+from a2a.types.a2a_pb2 import ListTasksRequest, Task, TaskState, TaskStatus
+from a2a.utils.constants import DEFAULT_LIST_TASKS_PAGE_SIZE
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.task import decode_list_tasks_cursor
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
 
 
-MINIMAL_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': {'state': 'submitted'},
-    'type': 'task',
-}
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+
+def _decoded_cursor(page_token: str) -> tuple[datetime | None, str] | None:
+    """The (timestamp, task ID) a page token resumes after; None on the last page."""
+    if not page_token:
+        return None
+    cursor = decode_list_tasks_cursor(page_token)
+    assert cursor is not None, 'expected a cursor token, not a legacy one'
+    timestamp = (
+        datetime(1970, 1, 1, tzinfo=timezone.utc)
+        + timedelta(microseconds=cursor.timestamp_ns // 1_000)
+        if cursor.timestamp_ns is not None
+        else None
+    )
+    return (timestamp, cursor.task_id)
+
+
+def create_minimal_task(
+    task_id: str = 'task-abc', context_id: str = 'session-xyz'
+) -> Task:
+    """Create a minimal task for testing."""
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
 
 
 @pytest.mark.asyncio
 async def test_in_memory_task_store_save_and_get() -> None:
     """Test saving and retrieving a task from the in-memory store."""
     store = InMemoryTaskStore()
-    task = Task(**MINIMAL_TASK)
-    await store.save(task)
-    retrieved_task = await store.get(MINIMAL_TASK['id'])
+    task = create_minimal_task()
+    await store.save(task, TEST_CONTEXT)
+    retrieved_task = await store.get('task-abc', TEST_CONTEXT)
     assert retrieved_task == task
 
 
@@ -28,18 +74,381 @@ async def test_in_memory_task_store_save_and_get() -> None:
 async def test_in_memory_task_store_get_nonexistent() -> None:
     """Test retrieving a nonexistent task."""
     store = InMemoryTaskStore()
-    retrieved_task = await store.get('nonexistent')
+    retrieved_task = await store.get('nonexistent', TEST_CONTEXT)
     assert retrieved_task is None
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'params, expected_ids, total_count, next_cursor',
+    [
+        # No parameters, should return all tasks
+        (
+            ListTasksRequest(),
+            ['task-2', 'task-1', 'task-0', 'task-4', 'task-3'],
+            5,
+            None,
+        ),
+        # Unknown context
+        (
+            ListTasksRequest(context_id='nonexistent'),
+            [],
+            0,
+            None,
+        ),
+        # Pagination (first page)
+        (
+            ListTasksRequest(page_size=2),
+            ['task-2', 'task-1'],
+            5,
+            (datetime(2025, 1, 1, tzinfo=timezone.utc), 'task-1'),
+        ),
+        # Pagination (same timestamp)
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0x',  # base64 for 'task-1'
+            ),
+            ['task-1', 'task-0'],
+            5,
+            (datetime(2025, 1, 1, tzinfo=timezone.utc), 'task-0'),
+        ),
+        # Pagination (final page)
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0z',  # base64 for 'task-3'
+            ),
+            ['task-3'],
+            5,
+            None,
+        ),
+        # Filtering by context_id
+        (
+            ListTasksRequest(context_id='context-1'),
+            ['task-1', 'task-3'],
+            2,
+            None,
+        ),
+        # Filtering by status
+        (
+            ListTasksRequest(status=TaskState.TASK_STATE_WORKING),
+            ['task-1', 'task-3'],
+            2,
+            None,
+        ),
+        # Combined filtering (context_id and status)
+        (
+            ListTasksRequest(
+                context_id='context-0', status=TaskState.TASK_STATE_SUBMITTED
+            ),
+            ['task-2', 'task-0'],
+            2,
+            None,
+        ),
+        # Combined filtering and pagination
+        (
+            ListTasksRequest(
+                context_id='context-0',
+                page_size=1,
+            ),
+            ['task-2'],
+            3,
+            (datetime(2025, 1, 2, tzinfo=timezone.utc), 'task-2'),
+        ),
+    ],
+)
+async def test_list_tasks(
+    params: ListTasksRequest,
+    expected_ids: list[str],
+    total_count: int,
+    next_cursor: tuple[datetime, str] | None,
+) -> None:
+    """Test listing tasks with various filters and pagination."""
+    store = InMemoryTaskStore()
+    tasks_to_create = [
+        Task(
+            id='task-0',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-1',
+            context_id='context-1',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_WORKING,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-2',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 2, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-3',
+            context_id='context-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        ),
+        Task(
+            id='task-4',
+            context_id='context-0',
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        ),
+    ]
+    for task in tasks_to_create:
+        await store.save(task, TEST_CONTEXT)
+
+    page = await store.list(params, TEST_CONTEXT)
+
+    retrieved_ids = [task.id for task in page.tasks]
+    assert retrieved_ids == expected_ids
+    assert page.total_size == total_count
+    assert _decoded_cursor(page.next_page_token) == next_cursor
+    assert page.page_size == (params.page_size or DEFAULT_LIST_TASKS_PAGE_SIZE)
+
+    # Cleanup
+    for task in tasks_to_create:
+        await store.delete(task.id, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'params, expected_error_message',
+    [
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='invalid',
+            ),
+            'Token is not a valid base64-encoded cursor.',
+        ),
+        (
+            ListTasksRequest(
+                page_size=2,
+                page_token='dGFzay0xMDA=',  # base64 for 'task-100'
+            ),
+            'Invalid page token: dGFzay0xMDA=',
+        ),
+    ],
+)
+async def test_list_tasks_fails(
+    params: ListTasksRequest, expected_error_message: str
+) -> None:
+    """Test listing tasks with invalid parameters that should fail."""
+    store = InMemoryTaskStore()
+    tasks_to_create = [
+        Task(
+            id='task-0',
+            context_id='context-0',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_SUBMITTED,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+        Task(
+            id='task-1',
+            context_id='context-1',
+            status=TaskStatus(
+                state=TaskState.TASK_STATE_WORKING,
+                timestamp=datetime(2025, 1, 1, tzinfo=timezone.utc),
+            ),
+        ),
+    ]
+    for task in tasks_to_create:
+        await store.save(task, TEST_CONTEXT)
+
+    with pytest.raises(InvalidParamsError) as excinfo:
+        await store.list(params, TEST_CONTEXT)
+
+    assert expected_error_message in str(excinfo.value)
+
+    # Cleanup
+    for task in tasks_to_create:
+        await store.delete(task.id, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'task_time, threshold, included',
+    [
+        ('00Z', '00.001Z', False),
+        ('00.001Z', '00Z', True),
+        ('00.123Z', '00.123001Z', False),
+        ('00.123001Z', '00.123Z', True),
+        ('00.123Z', '00.123000001Z', False),
+        ('00.123000001Z', '00.123Z', True),
+        ('00.123001Z', '00.123001001Z', False),
+        ('00.123001001Z', '00.123001Z', True),
+        ('00.123Z', '00.123Z', True),
+        ('00.123000001Z', '00.123000001Z', True),
+        ('00.999999999Z', '01Z', False),
+        ('01Z', '00.999999999Z', True),
+    ],
+)
+async def test_list_tasks_timestamp_filter_precision(
+    task_time: str, threshold: str, included: bool
+) -> None:
+    """Compare timestamp values across JSON fractional-second precisions."""
+    store = InMemoryTaskStore()
+    task = create_minimal_task()
+    task.status.timestamp.FromJsonString(f'2025-01-01T00:00:{task_time}')
+    await store.save(task, TEST_CONTEXT)
+    await store.save(create_minimal_task('no-timestamp'), TEST_CONTEXT)
+    await store.save(Task(id='no-status'), TEST_CONTEXT)
+    params = ListTasksRequest()
+    params.status_timestamp_after.FromJsonString(
+        f'2025-01-01T00:00:{threshold}'
+    )
+
+    page = await store.list(params, TEST_CONTEXT)
+
+    assert [result.id for result in page.tasks] == (
+        [task.id] if included else []
+    )
+    assert page.total_size == int(included)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('page_size', [1, 3, 20])
+async def test_list_tasks_timestamp_ordering_and_pagination(
+    page_size: int,
+) -> None:
+    """Keep chronological order and ID tie-breaking across page boundaries."""
+    store = InMemoryTaskStore()
+    # Chronological order, including timestamps before and at the Unix epoch.
+    timestamps = [
+        '1969-12-31T23:59:59.999999999Z',
+        '1970-01-01T00:00:00Z',
+        '2025-01-01T00:00:00Z',
+        '2025-01-01T00:00:00.123Z',
+        '2025-01-01T00:00:00.123000001Z',
+        '2025-01-01T00:00:00.123001Z',
+        '2025-01-01T00:00:00.123001001Z',
+        '2025-01-01T00:00:01Z',
+        '2025-01-01T00:00:01Z',
+    ]
+    for index, timestamp in enumerate(timestamps):
+        task = create_minimal_task(f'task-{index}')
+        task.status.timestamp.FromJsonString(timestamp)
+        await store.save(task, TEST_CONTEXT)
+    await store.save(create_minimal_task('no-timestamp'), TEST_CONTEXT)
+    await store.save(Task(id='no-status'), TEST_CONTEXT)
+    expected_ids = [
+        *(f'task-{index}' for index in reversed(range(len(timestamps)))),
+        'no-timestamp',
+        'no-status',
+    ]
+    params = ListTasksRequest(page_size=page_size)
+
+    for start in range(0, len(expected_ids), page_size):
+        page = await store.list(params, TEST_CONTEXT)
+        assert [task.id for task in page.tasks] == expected_ids[
+            start : start + page_size
+        ]
+        assert page.total_size == len(expected_ids)
+        assert bool(page.next_page_token) == (
+            start + page_size < len(expected_ids)
+        )
+        params.page_token = page.next_page_token
+
+
+async def _store_with_five_tasks() -> InMemoryTaskStore:
+    """t1..t5 with increasing timestamps, so they list as t5, t4, t3, t2, t1."""
+    store = InMemoryTaskStore()
+    for i in range(1, 6):
+        task = create_minimal_task(f't{i}')
+        task.status.timestamp.FromSeconds(1_700_000_000 + i)
+        await store.save(task, TEST_CONTEXT)
+    return store
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'change, task_id, expected_second_page',
+    [
+        # The last task returned moves to the top: the listing continues.
+        ('update', 't4', ['t3', 't2']),
+        # The next task moves above the cursor: skipped this pass, no repeats.
+        ('update', 't3', ['t2', 't1']),
+        # Deleting either task does not invalidate the token.
+        ('delete', 't4', ['t3', 't2']),
+        ('delete', 't3', ['t2', 't1']),
+    ],
+)
+async def test_list_tasks_page_token_survives_task_changes(
+    change: str, task_id: str, expected_second_page: list[str]
+) -> None:
+    """Regression test for #1280: the token is a position, not a task lookup."""
+    store = await _store_with_five_tasks()
+    first = await store.list(ListTasksRequest(page_size=2), TEST_CONTEXT)
+    assert [task.id for task in first.tasks] == ['t5', 't4']
+
+    if change == 'update':
+        task = create_minimal_task(task_id)
+        task.status.timestamp.FromSeconds(1_800_000_000)
+        await store.save(task, TEST_CONTEXT)
+    else:
+        await store.delete(task_id, TEST_CONTEXT)
+    second = await store.list(
+        ListTasksRequest(page_size=2, page_token=first.next_page_token),
+        TEST_CONTEXT,
+    )
+
+    assert [task.id for task in second.tasks] == expected_second_page
+
+
+@pytest.mark.asyncio
+async def test_list_tasks_pages_through_tasks_without_timestamps() -> None:
+    """Tasks without a timestamp sort last and are each returned once."""
+    store = InMemoryTaskStore()
+    timestamped = create_minimal_task('dated')
+    timestamped.status.timestamp.FromSeconds(1_700_000_000)
+    for task in (
+        timestamped,
+        create_minimal_task('undated-a'),
+        create_minimal_task('undated-b'),
+        Task(id='no-status'),
+    ):
+        await store.save(task, TEST_CONTEXT)
+
+    seen: list[str] = []
+    params = ListTasksRequest(page_size=1)
+    while True:
+        page = await store.list(params, TEST_CONTEXT)
+        seen.extend(task.id for task in page.tasks)
+        if not page.next_page_token:
+            break
+        params.page_token = page.next_page_token
+
+    assert seen == ['dated', 'undated-b', 'undated-a', 'no-status']
+
+
+@pytest.mark.asyncio
+async def test_list_tasks_rejects_malformed_cursor_token() -> None:
+    store = await _store_with_five_tasks()
+    token = urlsafe_b64encode(b'{"ts":"soon","id":"t1"}').decode().rstrip('=')
+
+    with pytest.raises(InvalidParamsError):
+        await store.list(
+            ListTasksRequest(page_size=2, page_token=token), TEST_CONTEXT
+        )
+
+
 @pytest.mark.asyncio
 async def test_in_memory_task_store_delete() -> None:
     """Test deleting a task from the store."""
     store = InMemoryTaskStore()
-    task = Task(**MINIMAL_TASK)
-    await store.save(task)
-    await store.delete(MINIMAL_TASK['id'])
-    retrieved_task = await store.get(MINIMAL_TASK['id'])
+    task = create_minimal_task()
+    await store.save(task, TEST_CONTEXT)
+    await store.delete('task-abc', TEST_CONTEXT)
+    retrieved_task = await store.get('task-abc', TEST_CONTEXT)
     assert retrieved_task is None
 
 
@@ -47,4 +456,161 @@ async def test_in_memory_task_store_delete() -> None:
 async def test_in_memory_task_store_delete_nonexistent() -> None:
     """Test deleting a nonexistent task."""
     store = InMemoryTaskStore()
-    await store.delete('nonexistent')
+    await store.delete('nonexistent', TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_owner_resource_scoping() -> None:
+    """Test that operations are scoped to the correct owner."""
+    store = InMemoryTaskStore()
+    task = create_minimal_task()
+
+    context_user1 = ServerCallContext(user=SampleUser(user_name='user1'))
+    context_user2 = ServerCallContext(user=SampleUser(user_name='user2'))
+    context_user3 = ServerCallContext(
+        user=SampleUser(user_name='user3')
+    )  # For testing non-existent user
+
+    # Create tasks for different owners
+    task1_user1 = Task()
+    task1_user1.CopyFrom(task)
+    task1_user1.id = 'u1-task1'
+
+    task2_user1 = Task()
+    task2_user1.CopyFrom(task)
+    task2_user1.id = 'u1-task2'
+
+    task1_user2 = Task()
+    task1_user2.CopyFrom(task)
+    task1_user2.id = 'u2-task1'
+
+    await store.save(task1_user1, context_user1)
+    await store.save(task2_user1, context_user1)
+    await store.save(task1_user2, context_user2)
+
+    # Test GET
+    assert await store.get('u1-task1', context_user1) is not None
+    assert await store.get('u1-task1', context_user2) is None
+    assert await store.get('u2-task1', context_user1) is None
+    assert await store.get('u2-task1', context_user2) is not None
+    assert await store.get('u2-task1', context_user3) is None
+
+    # Test LIST
+    params = ListTasksRequest()
+    page_user1 = await store.list(params, context_user1)
+    assert len(page_user1.tasks) == 2
+    assert {t.id for t in page_user1.tasks} == {'u1-task1', 'u1-task2'}
+    assert page_user1.total_size == 2
+
+    page_user2 = await store.list(params, context_user2)
+    assert len(page_user2.tasks) == 1
+    assert {t.id for t in page_user2.tasks} == {'u2-task1'}
+    assert page_user2.total_size == 1
+
+    page_user3 = await store.list(params, context_user3)
+    assert len(page_user3.tasks) == 0
+    assert page_user3.total_size == 0
+
+    # Test DELETE
+    await store.delete('u1-task1', context_user2)  # Should not delete
+    assert await store.get('u1-task1', context_user1) is not None
+
+    await store.delete('u1-task1', context_user1)  # Should delete
+    assert await store.get('u1-task1', context_user1) is None
+
+    # Cleanup remaining tasks
+    await store.delete('u1-task2', context_user1)
+    await store.delete('u2-task1', context_user2)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('use_copying', [True, False])
+async def test_inmemory_task_store_copying_behavior(use_copying: bool):
+    """Verify that tasks are copied (or not) based on use_copying parameter."""
+    store = InMemoryTaskStore(use_copying=use_copying)
+
+    original_task = Task(
+        id='test_task', status=TaskStatus(state=TaskState.TASK_STATE_WORKING)
+    )
+    await store.save(original_task, TEST_CONTEXT)
+
+    # Retrieve it
+    retrieved_task = await store.get('test_task', TEST_CONTEXT)
+    assert retrieved_task is not None
+
+    if use_copying:
+        assert retrieved_task is not original_task
+    else:
+        assert retrieved_task is original_task
+
+    # Modify retrieved task
+    retrieved_task.status.state = TaskState.TASK_STATE_COMPLETED
+
+    # Retrieve it again, it should NOT be modified in the store if use_copying=True
+    retrieved_task_2 = await store.get('test_task', TEST_CONTEXT)
+    assert retrieved_task_2 is not None
+
+    if use_copying:
+        assert retrieved_task_2.status.state == TaskState.TASK_STATE_WORKING
+        assert retrieved_task_2 is not retrieved_task
+    else:
+        assert retrieved_task_2.status.state == TaskState.TASK_STATE_COMPLETED
+        assert retrieved_task_2 is retrieved_task
+
+
+def _lock_is_owned(lock: threading.RLock) -> bool:
+    is_owned = getattr(lock, '_is_owned', None)
+    return bool(is_owned()) if callable(is_owned) else False
+
+
+def _save_task_in_thread(
+    store: InMemoryTaskStore,
+    task_id: str,
+    context: ServerCallContext,
+) -> None:
+    asyncio.run(store.save(create_minimal_task(task_id=task_id), context))
+
+
+def test_save_creates_owner_bucket_under_lock() -> None:
+    """Creating the first owner bucket must happen while the RLock is held."""
+    store = InMemoryTaskStore(use_copying=False)
+    impl = store._impl
+    lock_held: list[bool] = []
+
+    class _LockHeldOwnerMap(dict[str, dict[str, Task]]):
+        def setdefault(
+            self,
+            key: str,
+            default: dict[str, Task] | None = None,
+        ) -> dict[str, Task]:
+            lock_held.append(_lock_is_owned(impl.lock))
+            if default is None:
+                default = {}
+            return super().setdefault(key, default)
+
+        def __setitem__(self, key: str, value: dict[str, Task]) -> None:
+            lock_held.append(_lock_is_owned(impl.lock))
+            super().__setitem__(key, value)
+
+    impl.tasks = _LockHeldOwnerMap()
+    asyncio.run(store.save(create_minimal_task(), TEST_CONTEXT))
+    assert lock_held
+    assert all(lock_held)
+
+
+def test_concurrent_first_owner_saves_keep_both_tasks() -> None:
+    """Concurrent first saves for a new owner must keep both tasks."""
+    store = InMemoryTaskStore(use_copying=False)
+    context = ServerCallContext(user=SampleUser('race-owner'))
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:
+        futures = [
+            pool.submit(_save_task_in_thread, store, 'task-a', context),
+            pool.submit(_save_task_in_thread, store, 'task-b', context),
+        ]
+        for future in futures:
+            future.result(timeout=10)
+
+    page = asyncio.run(store.list(ListTasksRequest(), context))
+    assert {task.id for task in page.tasks} == {'task-a', 'task-b'}
+    assert asyncio.run(store.get('task-a', context)) is not None
+    assert asyncio.run(store.get('task-b', context)) is not None
diff --git a/tests/server/tasks/test_push_notification_sender.py b/tests/server/tasks/test_push_notification_sender.py
new file mode 100644
index 000000000..4772581b7
--- /dev/null
+++ b/tests/server/tasks/test_push_notification_sender.py
@@ -0,0 +1,448 @@
+import asyncio
+import unittest
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+
+from a2a.server.tasks.base_push_notification_sender import (
+    BasePushNotificationSender,
+)
+from a2a.types.a2a_pb2 import (
+    AuthenticationInfo,
+    StreamResponse,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils.push_url_validator import validate_push_notification_url
+from google.protobuf.json_format import MessageToDict
+
+
+def _create_sample_task(
+    task_id: str = 'task123',
+    status_state: TaskState = TaskState.TASK_STATE_COMPLETED,
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id='ctx456',
+        status=TaskStatus(state=status_state),
+    )
+
+
+def _create_sample_push_config(
+    url: str = 'http://example.com/callback',
+    config_id: str = 'cfg1',
+    token: str | None = None,
+    authentication: AuthenticationInfo | None = None,
+) -> TaskPushNotificationConfig:
+    return TaskPushNotificationConfig(
+        id=config_id, url=url, token=token, authentication=authentication
+    )
+
+
+class TestBasePushNotificationSender(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        self.mock_httpx_client = AsyncMock(spec=httpx.AsyncClient)
+        self.mock_config_store = AsyncMock()
+        self.sender = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.mock_config_store,
+        )
+
+    def test_constructor_stores_client_and_config_store(self) -> None:
+        self.assertEqual(self.sender._client, self.mock_httpx_client)
+        self.assertEqual(self.sender._config_store, self.mock_config_store)
+
+    async def test_send_notification_success(self) -> None:
+        task_id = 'task_send_success'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/here')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_data.id
+        )
+
+        # assert httpx_client post method got invoked with right parameters
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            config.url,
+            json=MessageToDict(StreamResponse(task=task_data)),
+            headers={},
+        )
+        mock_response.raise_for_status.assert_called_once()
+
+    async def test_send_notification_with_token_success(self) -> None:
+        task_id = 'task_send_success'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(
+            url='http://notify.me/here', token='unique_token'
+        )
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_data.id
+        )
+
+        # assert httpx_client post method got invoked with right parameters
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            config.url,
+            json=MessageToDict(StreamResponse(task=task_data)),
+            headers={'X-A2A-Notification-Token': 'unique_token'},
+        )
+        mock_response.raise_for_status.assert_called_once()
+
+    async def _post_headers_for(self, **config_kwargs) -> dict[str, str] | None:
+        """Sends one notification and returns the headers it posted with."""
+        task_data = _create_sample_task(task_id='task_auth')
+        self.mock_config_store.get_info_for_dispatch.return_value = [
+            _create_sample_push_config(**config_kwargs)
+        ]
+        self.mock_httpx_client.post.return_value = AsyncMock(
+            spec=httpx.Response, status_code=200
+        )
+
+        await self.sender.send_notification(task_data.id, task_data)
+
+        return self.mock_httpx_client.post.await_args.kwargs['headers']
+
+    async def test_authentication_becomes_an_authorization_header(self) -> None:
+        """Authentication becomes `Authorization: {scheme} {credentials}`."""
+        headers = await self._post_headers_for(
+            authentication=AuthenticationInfo(
+                scheme='Bearer', credentials='test-token'
+            )
+        )
+
+        assert headers == {'Authorization': 'Bearer test-token'}
+
+    async def test_authentication_and_token_are_sent_together(self) -> None:
+        headers = await self._post_headers_for(
+            token='notification-token',
+            authentication=AuthenticationInfo(
+                scheme='Bearer', credentials='test-token'
+            ),
+        )
+
+        assert headers == {
+            'X-A2A-Notification-Token': 'notification-token',
+            'Authorization': 'Bearer test-token',
+        }
+
+    async def test_authentication_without_credentials_sends_no_header(
+        self,
+    ) -> None:
+        """A half-filled AuthenticationInfo yields no 'Bearer ' with nothing after it."""
+        headers = await self._post_headers_for(
+            authentication=AuthenticationInfo(scheme='Bearer')
+        )
+
+        assert headers == {}
+
+    async def test_authentication_without_credentials_warns(self) -> None:
+        """A scheme with no credentials is valid to send, so say why it was dropped."""
+        with self.assertLogs(
+            'a2a.server.tasks.base_push_notification_sender', level='WARNING'
+        ) as logs:
+            await self._post_headers_for(
+                config_id='cfg-half-auth',
+                authentication=AuthenticationInfo(scheme='Bearer'),
+            )
+
+        assert any(
+            'cfg-half-auth' in line and 'no ' in line for line in logs.output
+        )
+
+    async def test_complete_authentication_does_not_warn(self) -> None:
+        with self.assertNoLogs(
+            'a2a.server.tasks.base_push_notification_sender', level='WARNING'
+        ):
+            await self._post_headers_for(
+                authentication=AuthenticationInfo(
+                    scheme='Bearer', credentials='test-token'
+                )
+            )
+
+    async def test_no_authentication_sends_no_authorization_header(
+        self,
+    ) -> None:
+        headers = await self._post_headers_for()
+
+        assert headers == {}
+
+    async def test_send_notification_no_config(self) -> None:
+        task_id = 'task_send_no_config'
+        task_data = _create_sample_task(task_id=task_id)
+        self.mock_config_store.get_info_for_dispatch.return_value = []
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.mock_httpx_client.post.assert_not_called()
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_send_notification_http_status_error(
+        self, mock_logger: MagicMock
+    ) -> None:
+        task_id = 'task_send_http_err'
+        task_data = _create_sample_task(task_id=task_id)
+        config = _create_sample_push_config(url='http://notify.me/http_error')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = 404
+        mock_response.text = 'Not Found'
+        http_error = httpx.HTTPStatusError(
+            'Not Found', request=MagicMock(), response=mock_response
+        )
+        self.mock_httpx_client.post.side_effect = http_error
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            config.url,
+            json=MessageToDict(StreamResponse(task=task_data)),
+            headers={},
+        )
+        mock_logger.exception.assert_called_once()
+
+    async def test_send_notification_multiple_configs(self) -> None:
+        task_id = 'task_multiple_configs'
+        task_data = _create_sample_task(task_id=task_id)
+        config1 = _create_sample_push_config(
+            url='http://notify.me/cfg1', config_id='cfg1'
+        )
+        config2 = _create_sample_push_config(
+            url='http://notify.me/cfg2', config_id='cfg2'
+        )
+        self.mock_config_store.get_info_for_dispatch.return_value = [
+            config1,
+            config2,
+        ]
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.assertEqual(self.mock_httpx_client.post.call_count, 2)
+
+        # Check calls for config1
+        self.mock_httpx_client.post.assert_any_call(
+            config1.url,
+            json=MessageToDict(StreamResponse(task=task_data)),
+            headers={},
+        )
+        # Check calls for config2
+        self.mock_httpx_client.post.assert_any_call(
+            config2.url,
+            json=MessageToDict(StreamResponse(task=task_data)),
+            headers={},
+        )
+        mock_response.raise_for_status.call_count = 2
+
+    async def test_send_notification_status_update_event(self) -> None:
+        task_id = 'task_status_update'
+        event = TaskStatusUpdateEvent(
+            task_id=task_id,
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+        config = _create_sample_push_config(url='http://notify.me/status')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.sender.send_notification(task_id, event)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            config.url,
+            json=MessageToDict(StreamResponse(status_update=event)),
+            headers={},
+        )
+
+    async def test_send_notification_artifact_update_event(self) -> None:
+        task_id = 'task_artifact_update'
+        event = TaskArtifactUpdateEvent(
+            task_id=task_id,
+            append=True,
+        )
+        config = _create_sample_push_config(url='http://notify.me/artifact')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+
+        await self.sender.send_notification(task_id, event)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.mock_httpx_client.post.assert_awaited_once_with(
+            config.url,
+            json=MessageToDict(StreamResponse(artifact_update=event)),
+            headers={},
+        )
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_send_notification_config_store_failure_is_swallowed(
+        self, mock_logger: MagicMock
+    ) -> None:
+        """A config store read failure is logged and delivery is skipped
+        instead of propagating into the task lifecycle (issue #1313)."""
+        task_id = 'task_store_error'
+        task_data = _create_sample_task(task_id=task_id)
+        self.mock_config_store.get_info_for_dispatch.side_effect = RuntimeError(
+            'transient DB error'
+        )
+
+        await self.sender.send_notification(task_id, task_data)
+
+        self.mock_config_store.get_info_for_dispatch.assert_awaited_once_with(
+            task_id
+        )
+        self.mock_httpx_client.post.assert_not_called()
+        mock_logger.exception.assert_called_once()
+
+    @patch('a2a.server.tasks.base_push_notification_sender.logger')
+    async def test_push_url_validator_raising_rejects_url(
+        self, mock_logger: MagicMock
+    ) -> None:
+        """A raising push_url_validator is treated as a rejected URL rather
+        than propagating into the task lifecycle (issue #1313)."""
+        sender = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.mock_config_store,
+            push_url_validator=AsyncMock(side_effect=RuntimeError('boom')),
+        )
+        task_data = _create_sample_task(task_id='task_validator_error')
+        config = _create_sample_push_config(url='http://notify.me/here')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+
+        await sender.send_notification(task_data.id, task_data)
+
+        self.mock_httpx_client.post.assert_not_called()
+        mock_logger.exception.assert_called_once()
+
+
+def _gai_result(ip: str, port: int = 80):
+    return [(2, 1, 6, '', (ip, port))]
+
+
+class TestPushUrlValidation(unittest.IsolatedAsyncioTestCase):
+    """SSRF hardening: when validate_push_notification_url is installed, client
+    push URLs must not reach non-public destinations."""
+
+    def setUp(self) -> None:
+        self.mock_httpx_client = AsyncMock(spec=httpx.AsyncClient)
+        self.mock_config_store = AsyncMock()
+        self.sender = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.mock_config_store,
+            push_url_validator=validate_push_notification_url,
+        )
+
+    async def _dispatch(self, url: str) -> None:
+        task = _create_sample_task()
+        config = _create_sample_push_config(url=url)
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+        await self.sender.send_notification(task.id, task)
+
+    def _patch_gai(self, *, return_value=None, side_effect=None):
+        loop = asyncio.get_running_loop()
+        mock_gai = AsyncMock(return_value=return_value, side_effect=side_effect)
+        return patch.object(loop, 'getaddrinfo', mock_gai)
+
+    async def test_metadata_endpoint_blocked(self) -> None:
+        with self._patch_gai(return_value=_gai_result('169.254.169.254')):
+            await self._dispatch('http://metadata.google.internal/latest')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_loopback_blocked(self) -> None:
+        with self._patch_gai(return_value=_gai_result('127.0.0.1')):
+            await self._dispatch('http://localhost:8080/admin')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_private_range_blocked(self) -> None:
+        with self._patch_gai(return_value=_gai_result('10.0.0.5')):
+            await self._dispatch('http://internal-service/endpoint')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_shared_address_space_blocked(self) -> None:
+        with self._patch_gai(return_value=_gai_result('100.64.0.1')):
+            await self._dispatch('http://shared.example/hook')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_ipv4_mapped_shared_address_blocked(self) -> None:
+        with self._patch_gai(return_value=_gai_result('::ffff:100.64.0.1')):
+            await self._dispatch('http://shared.example/hook')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_address_below_shared_space_allowed(self) -> None:
+        with self._patch_gai(return_value=_gai_result('100.63.255.255')):
+            await self._dispatch('http://notify.me/here')
+        self.mock_httpx_client.post.assert_awaited_once()
+
+    async def test_non_http_scheme_blocked(self) -> None:
+        await self._dispatch('ftp://example.com/file')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_invalid_port_blocked(self) -> None:
+        await self._dispatch('http://example.com:99999/hook')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_unresolvable_host_blocked_fail_closed(self) -> None:
+        with self._patch_gai(side_effect=OSError('no DNS')):
+            await self._dispatch('http://does-not-resolve.invalid/')
+        self.mock_httpx_client.post.assert_not_called()
+
+    async def test_public_host_allowed(self) -> None:
+        with self._patch_gai(return_value=_gai_result('93.184.216.34')):
+            await self._dispatch('http://notify.me/here')
+        self.mock_httpx_client.post.assert_awaited_once()
+
+    async def test_default_hook_none_skips_validation(self) -> None:
+        sender = BasePushNotificationSender(
+            httpx_client=self.mock_httpx_client,
+            config_store=self.mock_config_store,
+        )
+        task = _create_sample_task()
+        config = _create_sample_push_config(url='http://localhost:9000/hook')
+        self.mock_config_store.get_info_for_dispatch.return_value = [config]
+        mock_response = AsyncMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        self.mock_httpx_client.post.return_value = mock_response
+        await sender.send_notification(task.id, task)
+        self.mock_httpx_client.post.assert_awaited_once()
diff --git a/tests/server/tasks/test_result_aggregator.py b/tests/server/tasks/test_result_aggregator.py
new file mode 100644
index 000000000..6aca6685f
--- /dev/null
+++ b/tests/server/tasks/test_result_aggregator.py
@@ -0,0 +1,507 @@
+import asyncio
+import unittest
+
+from collections.abc import AsyncIterator
+from unittest.mock import ANY, AsyncMock, MagicMock, patch
+
+from a2a.server.events.event_consumer import EventConsumer
+from a2a.server.tasks.result_aggregator import ResultAggregator
+from a2a.server.tasks.task_manager import TaskManager
+from a2a.types.a2a_pb2 import (
+    Message,
+    Part,
+    Role,
+    Task,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from typing_extensions import override
+
+
+# Helper to create a simple message
+def create_sample_message(
+    content: str = 'test message',
+    msg_id: str = 'msg1',
+    role: Role = Role.ROLE_USER,
+) -> Message:
+    return Message(
+        message_id=msg_id,
+        role=role,
+        parts=[Part(text=content)],
+    )
+
+
+# Helper to create a simple task
+def create_sample_task(
+    task_id: str = 'task1',
+    status_state: TaskState = TaskState.TASK_STATE_SUBMITTED,
+    context_id: str = 'ctx1',
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=status_state),
+    )
+
+
+# Helper to create a TaskStatusUpdateEvent
+def create_sample_status_update(
+    task_id: str = 'task1',
+    status_state: TaskState = TaskState.TASK_STATE_WORKING,
+    context_id: str = 'ctx1',
+) -> TaskStatusUpdateEvent:
+    return TaskStatusUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=status_state),
+        # Typically false unless it's the very last update
+    )
+
+
+class TestResultAggregator(unittest.IsolatedAsyncioTestCase):
+    @override
+    def setUp(self) -> None:
+        self.mock_task_manager = AsyncMock(spec=TaskManager)
+        self.mock_event_consumer = AsyncMock(spec=EventConsumer)
+        self.aggregator = ResultAggregator(
+            task_manager=self.mock_task_manager
+            # event_consumer is not passed to constructor
+        )
+
+    def test_init_stores_task_manager(self) -> None:
+        self.assertEqual(self.aggregator.task_manager, self.mock_task_manager)
+        # event_consumer is also stored, can be tested if needed, but focus is on task_manager per req.
+
+    async def test_current_result_property_with_message_set(self) -> None:
+        sample_message = create_sample_message(content='hola')
+        self.aggregator._message = sample_message
+        self.assertEqual(await self.aggregator.current_result, sample_message)
+        self.mock_task_manager.get_task.assert_not_called()
+
+    async def test_current_result_property_with_message_none(self) -> None:
+        expected_task = create_sample_task(task_id='task_from_tm')
+        self.mock_task_manager.get_task.return_value = expected_task
+        self.aggregator._message = None
+
+        current_res = await self.aggregator.current_result
+
+        self.assertEqual(current_res, expected_task)
+        self.mock_task_manager.get_task.assert_called_once()
+
+    async def test_consume_and_emit(self) -> None:
+        event1 = create_sample_message(content='event one', msg_id='e1')
+        event2 = create_sample_task(
+            task_id='task_event', status_state=TaskState.TASK_STATE_WORKING
+        )
+        event3 = create_sample_status_update(
+            task_id='task_event', status_state=TaskState.TASK_STATE_COMPLETED
+        )
+
+        # Mock event_consumer.consume() to be an async generator
+        async def mock_consume_generator():
+            yield event1
+            yield event2
+            yield event3
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+
+        # To store yielded events
+        yielded_events = []
+        async for event in self.aggregator.consume_and_emit(
+            self.mock_event_consumer
+        ):
+            yielded_events.append(event)
+
+        # Assert that all events were yielded
+        self.assertEqual(len(yielded_events), 3)
+        self.assertIn(event1, yielded_events)
+        self.assertIn(event2, yielded_events)
+        self.assertIn(event3, yielded_events)
+
+        # Assert that task_manager.process was called for each event
+        self.assertEqual(self.mock_task_manager.process.call_count, 3)
+        self.mock_task_manager.process.assert_any_call(event1)
+        self.mock_task_manager.process.assert_any_call(event2)
+        self.mock_task_manager.process.assert_any_call(event3)
+
+    async def test_consume_all_only_message_event(self) -> None:
+        sample_message = create_sample_message(content='final message')
+
+        async def mock_consume_generator():
+            yield sample_message
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+
+        result = await self.aggregator.consume_all(self.mock_event_consumer)
+
+        self.assertEqual(result, sample_message)
+        self.mock_task_manager.process.assert_not_called()  # Process is not called if message is returned directly
+        self.mock_task_manager.get_task.assert_not_called()  # Should not be called if message is returned
+
+    async def test_consume_all_other_event_types(self) -> None:
+        task_event = create_sample_task(task_id='task_other_event')
+        status_update_event = create_sample_status_update(
+            task_id='task_other_event',
+            status_state=TaskState.TASK_STATE_COMPLETED,
+        )
+        final_task_state = create_sample_task(
+            task_id='task_other_event',
+            status_state=TaskState.TASK_STATE_COMPLETED,
+        )
+
+        async def mock_consume_generator():
+            yield task_event
+            yield status_update_event
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        self.mock_task_manager.get_task.return_value = final_task_state
+
+        result = await self.aggregator.consume_all(self.mock_event_consumer)
+
+        self.assertEqual(result, final_task_state)
+        self.assertEqual(self.mock_task_manager.process.call_count, 2)
+        self.mock_task_manager.process.assert_any_call(task_event)
+        self.mock_task_manager.process.assert_any_call(status_update_event)
+        self.mock_task_manager.get_task.assert_called_once()
+
+    async def test_consume_all_empty_stream(self) -> None:
+        empty_task_state = create_sample_task(task_id='empty_stream_task')
+
+        async def mock_consume_generator():
+            if False:  # Will not yield anything
+                yield
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        self.mock_task_manager.get_task.return_value = empty_task_state
+
+        result = await self.aggregator.consume_all(self.mock_event_consumer)
+
+        self.assertEqual(result, empty_task_state)
+        self.mock_task_manager.process.assert_not_called()
+        self.mock_task_manager.get_task.assert_called_once()
+
+    async def test_consume_all_event_consumer_exception(self) -> None:
+        class TestException(Exception):
+            pass
+
+        self.mock_event_consumer.consume_all = (
+            AsyncMock()
+        )  # Re-mock to make it an async generator that raises
+
+        async def raiser_gen():
+            # Yield a non-Message event first to ensure process is called
+            yield create_sample_task('task_before_error_consume_all')
+            raise TestException('Consumer error')
+
+        self.mock_event_consumer.consume_all = MagicMock(
+            return_value=raiser_gen()
+        )
+
+        with self.assertRaises(TestException):
+            await self.aggregator.consume_all(self.mock_event_consumer)
+
+        # Ensure process was called for the event before the exception
+        self.mock_task_manager.process.assert_called_once_with(
+            ANY  # Check it was called, arg is the task
+        )
+        self.mock_task_manager.get_task.assert_not_called()
+
+    async def test_consume_and_break_on_message(self) -> None:
+        sample_message = create_sample_message(content='interrupt message')
+        event_after = create_sample_task('task_after_msg')
+
+        async def mock_consume_generator():
+            yield sample_message
+            yield event_after  # This should not be processed by task_manager in this call
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+
+        (
+            result,
+            interrupted,
+            bg_task,
+        ) = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer
+        )
+
+        self.assertEqual(result, sample_message)
+        self.assertFalse(interrupted)
+        self.assertIsNone(bg_task)
+        self.mock_task_manager.process.assert_not_called()  # Process is not called for the Message if returned directly
+        # _continue_consuming should not be called if it's a message interrupt
+        # and no auth_required state.
+
+    @patch('asyncio.create_task')
+    async def test_consume_and_break_on_auth_required_task_event(
+        self, mock_create_task: MagicMock
+    ) -> None:
+        auth_task = create_sample_task(
+            task_id='auth_task', status_state=TaskState.TASK_STATE_AUTH_REQUIRED
+        )
+        event_after_auth = create_sample_message('after auth')
+
+        async def mock_consume_generator():
+            yield auth_task
+            yield event_after_auth  # This event will be handled by _continue_consuming
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        self.mock_task_manager.get_task.return_value = (
+            auth_task  # current_result after auth_task processing
+        )
+
+        # Mock _continue_consuming to check if it's called by create_task
+        self.aggregator._continue_consuming = AsyncMock()  # type: ignore[method-assign]
+        mock_create_task.side_effect = lambda coro: asyncio.ensure_future(coro)
+
+        (
+            result,
+            interrupted,
+            bg_task,
+        ) = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer
+        )
+
+        self.assertEqual(result, auth_task)
+        self.assertTrue(interrupted)
+        self.assertIsNotNone(bg_task)
+        self.mock_task_manager.process.assert_called_once_with(auth_task)
+        mock_create_task.assert_called_once()  # Check that create_task was called
+        # self.aggregator._continue_consuming is an AsyncMock.
+        # The actual call in product code is create_task(self._continue_consuming(event_stream_arg))
+        # So, we check that our mock _continue_consuming was called with an AsyncIterator arg.
+        self.aggregator._continue_consuming.assert_called_once()
+        self.assertIsInstance(
+            self.aggregator._continue_consuming.call_args[0][0], AsyncIterator
+        )
+
+        # Manually run the mocked _continue_consuming to check its behavior
+        # This requires the generator to be re-setup or passed if stateful.
+        # For simplicity, let's assume _continue_consuming uses the same generator instance.
+        # In a real scenario, the generator's state would be an issue.
+        # However, ResultAggregator re-assigns self.mock_event_consumer.consume()
+        # to self.aggregator._event_stream in the actual code.
+        # The test setup for _continue_consuming needs to be more robust if we want to test its internal loop.
+        # For now, we've verified it's called.
+
+    @patch('asyncio.create_task')
+    async def test_consume_and_break_on_auth_required_status_update_event(
+        self, mock_create_task: MagicMock
+    ) -> None:
+        auth_status_update = create_sample_status_update(
+            task_id='auth_status_task',
+            status_state=TaskState.TASK_STATE_AUTH_REQUIRED,
+        )
+        current_task_state_after_update = create_sample_task(
+            task_id='auth_status_task',
+            status_state=TaskState.TASK_STATE_AUTH_REQUIRED,
+        )
+
+        async def mock_consume_generator():
+            yield auth_status_update
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        # When current_result is called after processing auth_status_update
+        self.mock_task_manager.get_task.return_value = (
+            current_task_state_after_update
+        )
+        self.aggregator._continue_consuming = AsyncMock()  # type: ignore[method-assign]
+        mock_create_task.side_effect = lambda coro: asyncio.ensure_future(coro)
+
+        (
+            result,
+            interrupted,
+            bg_task,
+        ) = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer
+        )
+
+        self.assertEqual(result, current_task_state_after_update)
+        self.assertTrue(interrupted)
+        self.assertIsNotNone(bg_task)
+        self.mock_task_manager.process.assert_called_once_with(
+            auth_status_update
+        )
+        mock_create_task.assert_called_once()
+        self.aggregator._continue_consuming.assert_called_once()
+        self.assertIsInstance(
+            self.aggregator._continue_consuming.call_args[0][0], AsyncIterator
+        )
+
+    async def test_consume_and_break_completes_normally(self) -> None:
+        event1 = create_sample_message('event one normal', msg_id='n1')
+        event2 = create_sample_task('normal_task')
+        final_task_state = create_sample_task(
+            'normal_task', status_state=TaskState.TASK_STATE_COMPLETED
+        )
+
+        async def mock_consume_generator():
+            yield event1
+            yield event2
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        self.mock_task_manager.get_task.return_value = (
+            final_task_state  # For the end of stream
+        )
+
+        (
+            result,
+            interrupted,
+            bg_task,
+        ) = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer
+        )
+
+        # If the first event is a Message, it's returned directly.
+        self.assertEqual(result, event1)
+        self.assertFalse(interrupted)
+        self.assertIsNone(bg_task)
+        # process() is NOT called for the Message if it's the one causing the return
+        self.mock_task_manager.process.assert_not_called()
+        self.mock_task_manager.get_task.assert_not_called()
+
+    async def test_consume_and_break_event_consumer_exception(self) -> None:
+        class TestInterruptException(Exception):
+            pass
+
+        self.mock_event_consumer.consume_all = AsyncMock()
+
+        async def raiser_gen_interrupt():
+            # Yield a non-Message event first
+            yield create_sample_task('task_before_error_interrupt')
+            raise TestInterruptException(
+                'Consumer error during interrupt check'
+            )
+
+        self.mock_event_consumer.consume_all = MagicMock(
+            return_value=raiser_gen_interrupt()
+        )
+
+        with self.assertRaises(TestInterruptException):
+            await self.aggregator.consume_and_break_on_interrupt(
+                self.mock_event_consumer
+            )
+
+        self.mock_task_manager.process.assert_called_once_with(
+            ANY  # Check it was called, arg is the task
+        )
+        self.mock_task_manager.get_task.assert_not_called()
+
+    @patch('asyncio.create_task')
+    async def test_consume_and_break_non_blocking(
+        self, mock_create_task: MagicMock
+    ) -> None:
+        """Test that with blocking=False, the method returns after the first event."""
+        first_event = create_sample_task('non_blocking_task')
+        event_after = create_sample_message('should be consumed later')
+
+        async def mock_consume_generator():
+            yield first_event
+            yield event_after
+
+        self.mock_event_consumer.consume_all.return_value = (
+            mock_consume_generator()
+        )
+        # After processing `first_event`, the current result will be that task.
+        self.mock_task_manager.get_task.return_value = first_event
+
+        self.aggregator._continue_consuming = AsyncMock()  # type: ignore[method-assign]
+        mock_create_task.side_effect = lambda coro: asyncio.ensure_future(coro)
+
+        (
+            result,
+            interrupted,
+            bg_task,
+        ) = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer, blocking=False
+        )
+
+        self.assertEqual(result, first_event)
+        self.assertTrue(interrupted)
+        self.assertIsNotNone(bg_task)
+        self.mock_task_manager.process.assert_called_once_with(first_event)
+        mock_create_task.assert_called_once()
+        # The background task should be created with the remaining stream
+        self.aggregator._continue_consuming.assert_called_once()
+        self.assertIsInstance(
+            self.aggregator._continue_consuming.call_args[0][0], AsyncIterator
+        )
+
+    @patch('asyncio.create_task')  # To verify _continue_consuming is called
+    async def test_continue_consuming_processes_remaining_events(
+        self, mock_create_task: MagicMock
+    ) -> None:
+        # This test focuses on verifying that if an interrupt occurs,
+        # the events *after* the interrupting one are processed by _continue_consuming.
+
+        auth_event = create_sample_task(
+            'task_auth_for_continue',
+            status_state=TaskState.TASK_STATE_AUTH_REQUIRED,
+        )
+        event_after_auth1 = create_sample_message(
+            'after auth 1', msg_id='cont1'
+        )
+        event_after_auth2 = create_sample_task('task_after_auth_2')
+
+        # This generator will be iterated first by consume_and_break_on_interrupt,
+        # then by _continue_consuming.
+        # We need a way to simulate this shared iterator state or provide a new one for _continue_consuming.
+        # The actual implementation uses self.aggregator._event_stream
+
+        # Let's simulate the state after consume_and_break_on_interrupt has consumed auth_event
+        # and _event_stream is now the rest of the generator.
+
+        # Initial stream for consume_and_break_on_interrupt
+        async def initial_consume_generator():
+            yield auth_event
+            # These should be consumed by _continue_consuming
+            yield event_after_auth1
+            yield event_after_auth2
+
+        self.mock_event_consumer.consume_all.return_value = (
+            initial_consume_generator()
+        )
+        self.mock_task_manager.get_task.return_value = (
+            auth_event  # Task state at interrupt
+        )
+        mock_create_task.side_effect = lambda coro: asyncio.ensure_future(coro)
+
+        # Call the main method that triggers _continue_consuming via create_task
+        _, _, _ = await self.aggregator.consume_and_break_on_interrupt(
+            self.mock_event_consumer
+        )
+
+        mock_create_task.assert_called_once()
+        # Now, we need to actually execute the coroutine passed to create_task
+        # to test the behavior of _continue_consuming
+        continue_consuming_coro = mock_create_task.call_args[0][0]
+
+        # Reset process mock to only count calls from _continue_consuming
+        self.mock_task_manager.process.reset_mock()
+
+        await continue_consuming_coro
+
+        # Verify process was called for events after the interrupt
+        self.assertEqual(self.mock_task_manager.process.call_count, 2)
+        self.mock_task_manager.process.assert_any_call(event_after_auth1)
+        self.mock_task_manager.process.assert_any_call(event_after_auth2)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/server/tasks/test_task_manager.py b/tests/server/tasks/test_task_manager.py
index aae189fd8..dc8306d06 100644
--- a/tests/server/tasks/test_task_manager.py
+++ b/tests/server/tasks/test_task_manager.py
@@ -3,8 +3,12 @@
 
 import pytest
 
+from a2a.auth.user import User
+from a2a.server.cluster import VersionedTaskStore
+from a2a.server.context import ServerCallContext
 from a2a.server.tasks import TaskManager
-from a2a.types import (
+from a2a.server.tasks.task_manager import append_artifact_to_task
+from a2a.types.a2a_pb2 import (
     Artifact,
     Message,
     Part,
@@ -14,16 +18,42 @@
     TaskState,
     TaskStatus,
     TaskStatusUpdateEvent,
-    TextPart,
 )
+from a2a.utils.errors import InvalidAgentResponseError, InvalidParamsError
 
 
-MINIMAL_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': {'state': 'submitted'},
-    'type': 'task',
-}
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+TEST_CONTEXT = ServerCallContext(user=SampleUser('test_user'))
+
+
+# Create proto task instead of dict
+def create_minimal_task(
+    task_id: str = 'task-abc',
+    context_id: str = 'session-xyz',
+) -> Task:
+    return Task(
+        id=task_id,
+        context_id=context_id,
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+
+MINIMAL_TASK_ID = 'task-abc'
+MINIMAL_CONTEXT_ID = 'session-xyz'
 
 
 @pytest.fixture
@@ -36,23 +66,39 @@ def mock_task_store() -> AsyncMock:
 def task_manager(mock_task_store: AsyncMock) -> TaskManager:
     """Fixture for a TaskManager with a mock TaskStore."""
     return TaskManager(
-        task_id=MINIMAL_TASK['id'],
-        context_id=MINIMAL_TASK['contextId'],
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
         task_store=mock_task_store,
         initial_message=None,
+        context=TEST_CONTEXT,
     )
 
 
+@pytest.mark.parametrize('invalid_task_id', ['', 123])
+def test_task_manager_invalid_task_id(
+    mock_task_store: AsyncMock, invalid_task_id: Any
+):
+    """Test that TaskManager raises ValueError for an invalid task_id."""
+    with pytest.raises(ValueError, match='Task ID must be a non-empty string'):
+        TaskManager(
+            task_id=invalid_task_id,
+            context_id='test_context',
+            task_store=mock_task_store,
+            initial_message=None,
+            context=TEST_CONTEXT,
+        )
+
+
 @pytest.mark.asyncio
 async def test_get_task_existing(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test getting an existing task."""
-    expected_task = Task(**MINIMAL_TASK)
+    expected_task = create_minimal_task()
     mock_task_store.get.return_value = expected_task
     retrieved_task = await task_manager.get_task()
     assert retrieved_task == expected_task
-    mock_task_store.get.assert_called_once_with(MINIMAL_TASK['id'])
+    mock_task_store.get.assert_called_once_with(MINIMAL_TASK_ID, TEST_CONTEXT)
 
 
 @pytest.mark.asyncio
@@ -63,7 +109,7 @@ async def test_get_task_nonexistent(
     mock_task_store.get.return_value = None
     retrieved_task = await task_manager.get_task()
     assert retrieved_task is None
-    mock_task_store.get.assert_called_once_with(MINIMAL_TASK['id'])
+    mock_task_store.get.assert_called_once_with(MINIMAL_TASK_ID, TEST_CONTEXT)
 
 
 @pytest.mark.asyncio
@@ -71,9 +117,9 @@ async def test_save_task_event_new_task(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test saving a new task."""
-    task = Task(**MINIMAL_TASK)
+    task = create_minimal_task()
     await task_manager.save_task_event(task)
-    mock_task_store.save.assert_called_once_with(task)
+    mock_task_store.save.assert_called_once_with(task, TEST_CONTEXT)
 
 
 @pytest.mark.asyncio
@@ -81,26 +127,27 @@ async def test_save_task_event_status_update(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test saving a status update for an existing task."""
-    initial_task = Task(**MINIMAL_TASK)
+    initial_task = create_minimal_task()
     mock_task_store.get.return_value = initial_task
     new_status = TaskStatus(
-        state=TaskState.working,
+        state=TaskState.TASK_STATE_WORKING,
         message=Message(
-            role=Role.agent,
-            parts=[Part(TextPart(text='content'))],
-            messageId='message-id',
+            role=Role.ROLE_AGENT,
+            parts=[Part(text='content')],
+            message_id='message-id',
         ),
     )
     event = TaskStatusUpdateEvent(
-        taskId=MINIMAL_TASK['id'],
-        contextId=MINIMAL_TASK['contextId'],
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
         status=new_status,
-        final=False,
     )
     await task_manager.save_task_event(event)
-    updated_task = initial_task
-    updated_task.status = new_status
-    mock_task_store.save.assert_called_once_with(updated_task)
+    # Verify save was called and the task has updated status
+    call_args = mock_task_store.save.call_args
+    assert call_args is not None
+    saved_task = call_args[0][0]
+    assert saved_task.status.state == TaskState.TASK_STATE_WORKING
 
 
 @pytest.mark.asyncio
@@ -108,22 +155,110 @@ async def test_save_task_event_artifact_update(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test saving an artifact update for an existing task."""
-    initial_task = Task(**MINIMAL_TASK)
+    initial_task = create_minimal_task()
     mock_task_store.get.return_value = initial_task
     new_artifact = Artifact(
-        artifactId='artifact-id',
+        artifact_id='artifact-id',
         name='artifact1',
-        parts=[Part(TextPart(text='content'))],
+        parts=[Part(text='content')],
     )
     event = TaskArtifactUpdateEvent(
-        taskId=MINIMAL_TASK['id'],
-        contextId=MINIMAL_TASK['contextId'],
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
         artifact=new_artifact,
     )
     await task_manager.save_task_event(event)
-    updated_task = initial_task
-    updated_task.artifacts = [new_artifact]
-    mock_task_store.save.assert_called_once_with(updated_task)
+    # Verify save was called and the task has the artifact
+    call_args = mock_task_store.save.call_args
+    assert call_args is not None
+    saved_task = call_args[0][0]
+    assert len(saved_task.artifacts) == 1
+    assert saved_task.artifacts[0].artifact_id == 'artifact-id'
+
+
+@pytest.mark.asyncio
+async def test_save_task_event_metadata_update(
+    task_manager: TaskManager, mock_task_store: AsyncMock
+) -> None:
+    """Test saving an updated metadata for an existing task."""
+    initial_task = create_minimal_task()
+    mock_task_store.get.return_value = initial_task
+    new_metadata = {'meta_key_test': 'meta_value_test'}
+
+    event = TaskStatusUpdateEvent(
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
+        metadata=new_metadata,
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+    )
+    await task_manager.save_task_event(event)
+
+    updated_task = mock_task_store.save.call_args.args[0]
+    assert updated_task.metadata == new_metadata
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'event',
+    [
+        TaskStatusUpdateEvent(
+            task_id=MINIMAL_TASK_ID,
+            context_id=MINIMAL_CONTEXT_ID,
+            status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
+        ),
+        TaskArtifactUpdateEvent(
+            task_id=MINIMAL_TASK_ID,
+            context_id=MINIMAL_CONTEXT_ID,
+            artifact=Artifact(
+                artifact_id='artifact-id', parts=[Part(text='chunk')]
+            ),
+        ),
+    ],
+    ids=['status', 'artifact'],
+)
+async def test_save_task_event_failed_save_keeps_cached_task(
+    task_manager: TaskManager,
+    mock_task_store: AsyncMock,
+    event: TaskStatusUpdateEvent | TaskArtifactUpdateEvent,
+) -> None:
+    """A rejected write leaves the cached task as it was last persisted."""
+    mock_task_store.get.return_value = create_minimal_task()
+    await task_manager.get_task()
+    mock_task_store.save.side_effect = ConnectionError('connection lost')
+
+    with pytest.raises(ConnectionError):
+        await task_manager.save_task_event(event)
+
+    task = await task_manager.get_task()
+    assert task is not None
+    assert task.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert not task.artifacts
+
+
+@pytest.mark.asyncio
+async def test_save_task_event_passes_previous_task_as_prev() -> None:
+    """A versioned store receives the task as it was before the event."""
+    store = AsyncMock(spec=VersionedTaskStore)
+    task_manager = TaskManager(
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
+        task_store=store,
+        initial_message=None,
+        context=TEST_CONTEXT,
+    )
+    await task_manager.save_task_event(create_minimal_task())
+
+    await task_manager.save_task_event(
+        TaskStatusUpdateEvent(
+            task_id=MINIMAL_TASK_ID,
+            context_id=MINIMAL_CONTEXT_ID,
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+    )
+
+    call = store.save.call_args
+    assert call.args[0].status.state == TaskState.TASK_STATE_WORKING
+    assert call.kwargs['prev'].status.state == TaskState.TASK_STATE_SUBMITTED
 
 
 @pytest.mark.asyncio
@@ -131,17 +266,16 @@ async def test_ensure_task_existing(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test ensuring an existing task."""
-    expected_task = Task(**MINIMAL_TASK)
+    expected_task = create_minimal_task()
     mock_task_store.get.return_value = expected_task
     event = TaskStatusUpdateEvent(
-        taskId=MINIMAL_TASK['id'],
-        contextId=MINIMAL_TASK['contextId'],
-        status=TaskStatus(state=TaskState.working),
-        final=False,
+        task_id=MINIMAL_TASK_ID,
+        context_id=MINIMAL_CONTEXT_ID,
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
     )
     retrieved_task = await task_manager.ensure_task(event)
     assert retrieved_task == expected_task
-    mock_task_store.get.assert_called_once_with(MINIMAL_TASK['id'])
+    mock_task_store.get.assert_called_once_with(MINIMAL_TASK_ID, TEST_CONTEXT)
 
 
 @pytest.mark.asyncio
@@ -155,18 +289,18 @@ async def test_ensure_task_nonexistent(
         context_id=None,
         task_store=mock_task_store,
         initial_message=None,
+        context=TEST_CONTEXT,
     )
     event = TaskStatusUpdateEvent(
-        taskId='new-task',
-        contextId='some-context',
-        status=TaskStatus(state=TaskState.submitted),
-        final=False,
+        task_id='new-task',
+        context_id='some-context',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
     )
     new_task = await task_manager_without_id.ensure_task(event)
     assert new_task.id == 'new-task'
-    assert new_task.contextId == 'some-context'
-    assert new_task.status.state == TaskState.submitted
-    mock_task_store.save.assert_called_once_with(new_task)
+    assert new_task.context_id == 'some-context'
+    assert new_task.status.state == TaskState.TASK_STATE_SUBMITTED
+    mock_task_store.save.assert_called_once_with(new_task, TEST_CONTEXT)
     assert task_manager_without_id.task_id == 'new-task'
     assert task_manager_without_id.context_id == 'some-context'
 
@@ -175,8 +309,8 @@ def test_init_task_obj(task_manager: TaskManager) -> None:
     """Test initializing a new task object."""
     new_task = task_manager._init_task_obj('new-task', 'new-context')  # type: ignore
     assert new_task.id == 'new-task'
-    assert new_task.contextId == 'new-context'
-    assert new_task.status.state == TaskState.submitted
+    assert new_task.context_id == 'new-context'
+    assert new_task.status.state == TaskState.TASK_STATE_SUBMITTED
     assert new_task.history == []
 
 
@@ -185,9 +319,26 @@ async def test_save_task(
     task_manager: TaskManager, mock_task_store: AsyncMock
 ) -> None:
     """Test saving a task."""
-    task = Task(**MINIMAL_TASK)
+    task = create_minimal_task()
     await task_manager._save_task(task)  # type: ignore
-    mock_task_store.save.assert_called_once_with(task)
+    mock_task_store.save.assert_called_once_with(task, TEST_CONTEXT)
+
+
+@pytest.mark.asyncio
+async def test_save_task_event_mismatched_id_raises_error(
+    task_manager: TaskManager,
+) -> None:
+    """Test that save_task_event raises InvalidParamsError on task ID mismatch."""
+    # The task_manager is initialized with 'task-abc'
+    mismatched_task = Task(
+        id='wrong-id',
+        context_id='session-xyz',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        await task_manager.save_task_event(mismatched_task)
+    assert exc_info.value is not None
 
 
 @pytest.mark.asyncio
@@ -200,20 +351,19 @@ async def test_save_task_event_new_task_no_task_id(
         context_id=None,
         task_store=mock_task_store,
         initial_message=None,
+        context=TEST_CONTEXT,
+    )
+    task = Task(
+        id='new-task-id',
+        context_id='some-context',
+        status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
     )
-    task_data: dict[str, Any] = {
-        'id': 'new-task-id',
-        'contextId': 'some-context',
-        'status': {'state': 'working'},
-        'type': 'task',
-    }
-    task = Task(**task_data)
     await task_manager_without_id.save_task_event(task)
-    mock_task_store.save.assert_called_once_with(task)
+    mock_task_store.save.assert_called_once_with(task, TEST_CONTEXT)
     assert task_manager_without_id.task_id == 'new-task-id'
     assert task_manager_without_id.context_id == 'some-context'
     # initial submit should be updated to working
-    assert task.status.state == TaskState.working
+    assert task.status.state == TaskState.TASK_STATE_WORKING
 
 
 @pytest.mark.asyncio
@@ -226,6 +376,7 @@ async def test_get_task_no_task_id(
         context_id='some-context',
         task_store=mock_task_store,
         initial_message=None,
+        context=TEST_CONTEXT,
     )
     retrieved_task = await task_manager_without_id.get_task()
     assert retrieved_task is None
@@ -242,13 +393,13 @@ async def test_save_task_event_no_task_existing(
         context_id=None,
         task_store=mock_task_store,
         initial_message=None,
+        context=TEST_CONTEXT,
     )
     mock_task_store.get.return_value = None
     event = TaskStatusUpdateEvent(
-        taskId='event-task-id',
-        contextId='some-context',
-        status=TaskStatus(state=TaskState.completed),
-        final=True,
+        task_id='event-task-id',
+        context_id='some-context',
+        status=TaskStatus(state=TaskState.TASK_STATE_COMPLETED),
     )
     await task_manager_without_id.save_task_event(event)
     # Check if a new task was created and saved
@@ -256,7 +407,105 @@ async def test_save_task_event_no_task_existing(
     assert call_args is not None
     saved_task = call_args[0][0]
     assert saved_task.id == 'event-task-id'
-    assert saved_task.contextId == 'some-context'
-    assert saved_task.status.state == TaskState.completed
+    assert saved_task.context_id == 'some-context'
+    assert saved_task.status.state == TaskState.TASK_STATE_COMPLETED
     assert task_manager_without_id.task_id == 'event-task-id'
     assert task_manager_without_id.context_id == 'some-context'
+
+
+def test_append_artifact_to_task():
+    # Prepare base task
+    task = create_minimal_task()
+    assert task.id == 'task-abc'
+    assert task.context_id == 'session-xyz'
+    assert task.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert len(task.history) == 0  # proto repeated fields are empty, not None
+    assert len(task.artifacts) == 0
+
+    # Prepare appending artifact and event
+    artifact_1 = Artifact(
+        artifact_id='artifact-123', parts=[Part(text='Hello')]
+    )
+    append_event_1 = TaskArtifactUpdateEvent(
+        artifact=artifact_1, append=False, task_id='123', context_id='123'
+    )
+
+    # Test adding a new artifact (not appending)
+    append_artifact_to_task(task, append_event_1)
+    assert len(task.artifacts) == 1
+    assert task.artifacts[0].artifact_id == 'artifact-123'
+    assert task.artifacts[0].name == ''  # proto default for string
+    assert len(task.artifacts[0].parts) == 1
+    assert task.artifacts[0].parts[0].text == 'Hello'
+
+    # Test replacing the artifact
+    artifact_2 = Artifact(
+        artifact_id='artifact-123',
+        name='updated name',
+        parts=[Part(text='Updated')],
+        metadata={'existing_key': 'existing_value'},
+    )
+    append_event_2 = TaskArtifactUpdateEvent(
+        artifact=artifact_2, append=False, task_id='123', context_id='123'
+    )
+    append_artifact_to_task(task, append_event_2)
+    assert len(task.artifacts) == 1  # Should still have one artifact
+    assert task.artifacts[0].artifact_id == 'artifact-123'
+    assert task.artifacts[0].name == 'updated name'
+    assert len(task.artifacts[0].parts) == 1
+    assert task.artifacts[0].parts[0].text == 'Updated'
+    assert task.artifacts[0].metadata['existing_key'] == 'existing_value'
+
+    # Test appending parts to an existing artifact
+    artifact_with_parts = Artifact(
+        artifact_id='artifact-123',
+        parts=[Part(text='Part 2')],
+        metadata={'new_key': 'new_value'},
+    )
+    append_event_3 = TaskArtifactUpdateEvent(
+        artifact=artifact_with_parts,
+        append=True,
+        task_id='123',
+        context_id='123',
+    )
+    append_artifact_to_task(task, append_event_3)
+    assert len(task.artifacts[0].parts) == 2
+    assert task.artifacts[0].parts[0].text == 'Updated'
+    assert task.artifacts[0].parts[1].text == 'Part 2'
+    assert task.artifacts[0].metadata['existing_key'] == 'existing_value'
+    assert task.artifacts[0].metadata['new_key'] == 'new_value'
+
+    # Test adding another new artifact
+    another_artifact_with_parts = Artifact(
+        artifact_id='new_artifact',
+        parts=[Part(text='new artifact Part 1')],
+    )
+    append_event_4 = TaskArtifactUpdateEvent(
+        artifact=another_artifact_with_parts,
+        append=False,
+        task_id='123',
+        context_id='123',
+    )
+    append_artifact_to_task(task, append_event_4)
+    assert len(task.artifacts) == 2
+    assert task.artifacts[0].artifact_id == 'artifact-123'
+    assert task.artifacts[1].artifact_id == 'new_artifact'
+    assert len(task.artifacts[0].parts) == 2
+    assert len(task.artifacts[1].parts) == 1
+
+    # Test appending part to a task that does not have a matching artifact
+    # should raise InvalidAgentResponseError instead of silently dropping (#1038)
+    non_existing_artifact_with_parts = Artifact(
+        artifact_id='artifact-456', parts=[Part(text='Part 1')]
+    )
+    append_event_5 = TaskArtifactUpdateEvent(
+        artifact=non_existing_artifact_with_parts,
+        append=True,
+        task_id='123',
+        context_id='123',
+    )
+    with pytest.raises(
+        InvalidAgentResponseError,
+        match='append=True for nonexistent artifact_id',
+    ):
+        append_artifact_to_task(task, append_event_5)
diff --git a/tests/server/tasks/test_task_manager_plugins.py b/tests/server/tasks/test_task_manager_plugins.py
new file mode 100644
index 000000000..e7ece4e57
--- /dev/null
+++ b/tests/server/tasks/test_task_manager_plugins.py
@@ -0,0 +1,163 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from a2a import plugins
+from a2a.plugins import TaskEventInfo, TaskObserverPlugin
+from a2a.server.cluster.task_store import ConcurrentTaskModificationError
+from a2a.server.context import ServerCallContext
+from a2a.server.tasks import InMemoryTaskStore, TaskManager
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    Part,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+
+
+class Collect(TaskObserverPlugin):
+    def __init__(self) -> None:
+        self.infos: list[TaskEventInfo] = []
+
+    async def on_task_event(self, info: TaskEventInfo) -> None:
+        self.infos.append(info)
+
+    def transitions(self) -> list[tuple]:
+        return [(i.from_state, i.to_state) for i in self.infos]
+
+
+def status(task_id: str, state: TaskState) -> TaskStatusUpdateEvent:
+    return TaskStatusUpdateEvent(
+        task_id=task_id, context_id='c-1', status=TaskStatus(state=state)
+    )
+
+
+def manager(store, collect, task_id='t-1') -> TaskManager:
+    return TaskManager(
+        task_store=store,
+        context=ServerCallContext(),
+        task_id=task_id,
+        context_id='c-1',
+        initial_message=None,
+        plugins=plugins.sequential(collect),
+    )
+
+
+@pytest.mark.asyncio
+async def test_transitions_from_creation_to_completion():
+    collect = Collect()
+    tm = manager(InMemoryTaskStore(), collect)
+
+    await tm.save_task_event(status('t-1', TaskState.TASK_STATE_WORKING))
+    await tm.save_task_event(
+        TaskArtifactUpdateEvent(
+            task_id='t-1',
+            context_id='c-1',
+            artifact=Artifact(artifact_id='a-1', parts=[Part(text='x')]),
+        )
+    )
+    await tm.save_task_event(status('t-1', TaskState.TASK_STATE_COMPLETED))
+
+    W, S, C = (
+        TaskState.TASK_STATE_WORKING,
+        TaskState.TASK_STATE_SUBMITTED,
+        TaskState.TASK_STATE_COMPLETED,
+    )
+    assert collect.transitions() == [(None, S), (S, W), (W, W), (W, C)]
+    # The creation write has no event; the others carry the agent event.
+    assert collect.infos[0].event is None
+    assert isinstance(collect.infos[1].event, TaskStatusUpdateEvent)
+    assert isinstance(collect.infos[2].event, TaskArtifactUpdateEvent)
+    assert collect.infos[-1].task.status.state == C
+
+
+@pytest.mark.asyncio
+async def test_from_state_comes_from_existing_task_in_store():
+    store = InMemoryTaskStore()
+    context = ServerCallContext()
+    await store.save(
+        Task(
+            id='t-1',
+            context_id='c-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_INPUT_REQUIRED),
+        ),
+        context,
+    )
+    collect = Collect()
+    tm = manager(store, collect)
+
+    await tm.save_task_event(status('t-1', TaskState.TASK_STATE_WORKING))
+
+    assert collect.transitions() == [
+        (TaskState.TASK_STATE_INPUT_REQUIRED, TaskState.TASK_STATE_WORKING)
+    ]
+
+
+@pytest.mark.asyncio
+async def test_get_task_and_invalidate_refresh_persisted_state():
+    store = InMemoryTaskStore()
+    context = ServerCallContext()
+    collect = Collect()
+    tm = manager(store, collect)
+    assert await tm.get_task() is None
+
+    await tm.save_task_event(
+        Task(
+            id='t-1',
+            context_id='c-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+        )
+    )
+    # Another writer advances the task behind the manager's back.
+    await store.save(
+        Task(
+            id='t-1',
+            context_id='c-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        ),
+        context,
+    )
+    tm.invalidate()
+    assert (await tm.get_task()).status.state == TaskState.TASK_STATE_WORKING
+    await tm.save_task_event(status('t-1', TaskState.TASK_STATE_COMPLETED))
+
+    assert collect.transitions() == [
+        (None, TaskState.TASK_STATE_SUBMITTED),
+        (TaskState.TASK_STATE_WORKING, TaskState.TASK_STATE_COMPLETED),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_failed_write_reports_nothing():
+    collect = Collect()
+    store = InMemoryTaskStore()
+    tm = manager(store, collect)
+    tm._versioned_store.save = AsyncMock(
+        side_effect=ConcurrentTaskModificationError('stale')
+    )
+
+    with pytest.raises(ConcurrentTaskModificationError):
+        await tm.save_task_event(status('t-1', TaskState.TASK_STATE_WORKING))
+
+    assert collect.infos == []
+
+
+@pytest.mark.asyncio
+async def test_no_plugins_or_no_task_hooks_reports_nothing():
+    class OnlyServer(plugins.ServerPlugin):
+        pass
+
+    for manager_arg in (None, plugins.sequential(OnlyServer())):
+        tm = TaskManager(
+            task_store=InMemoryTaskStore(),
+            context=ServerCallContext(),
+            task_id='t-1',
+            context_id='c-1',
+            initial_message=None,
+            plugins=manager_arg,
+        )
+        assert tm._plugins is None
+        await tm.save_task_event(status('t-1', TaskState.TASK_STATE_WORKING))
diff --git a/tests/server/tasks/test_task_updater.py b/tests/server/tasks/test_task_updater.py
new file mode 100644
index 000000000..4756ee087
--- /dev/null
+++ b/tests/server/tasks/test_task_updater.py
@@ -0,0 +1,676 @@
+import asyncio
+import uuid
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from a2a.server.events import EventQueue
+from a2a.server.id_generator import IDGenerator
+from a2a.server.tasks import TaskUpdater
+from a2a.types.a2a_pb2 import (
+    Message,
+    Part,
+    Role,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatusUpdateEvent,
+)
+
+
+@pytest.fixture
+def event_queue() -> AsyncMock:
+    """Create a mock event queue for testing."""
+    return AsyncMock(spec=EventQueue)
+
+
+@pytest.fixture
+def task_updater(event_queue: AsyncMock) -> TaskUpdater:
+    """Create a TaskUpdater instance for testing."""
+    return TaskUpdater(
+        event_queue=event_queue,
+        task_id='test-task-id',
+        context_id='test-context-id',
+    )
+
+
+@pytest.fixture
+def sample_message() -> Message:
+    """Create a sample message for testing."""
+    return Message(
+        role=Role.ROLE_AGENT,
+        task_id='test-task-id',
+        context_id='test-context-id',
+        message_id='test-message-id',
+        parts=[Part(text='Test message')],
+    )
+
+
+@pytest.fixture
+def sample_parts() -> list[Part]:
+    """Create sample parts for testing."""
+    return [Part(text='Test part')]
+
+
+def test_init(event_queue: AsyncMock) -> None:
+    """Test that TaskUpdater initializes correctly."""
+    task_updater = TaskUpdater(
+        event_queue=event_queue,
+        task_id='test-task-id',
+        context_id='test-context-id',
+    )
+
+    assert task_updater.event_queue == event_queue
+    assert task_updater.task_id == 'test-task-id'
+    assert task_updater.context_id == 'test-context-id'
+
+
+@pytest.mark.asyncio
+async def test_update_status_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test updating status without a message."""
+    await task_updater.update_status(TaskState.TASK_STATE_WORKING)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.task_id == 'test-task-id'
+    assert event.context_id == 'test-context-id'
+    assert event.status.state == TaskState.TASK_STATE_WORKING
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_update_status_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test updating status with a message."""
+    await task_updater.update_status(
+        TaskState.TASK_STATE_WORKING, message=sample_message
+    )
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.task_id == 'test-task-id'
+    assert event.context_id == 'test-context-id'
+    assert event.status.state == TaskState.TASK_STATE_WORKING
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_update_status_final(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test updating status with ."""
+    await task_updater.update_status(TaskState.TASK_STATE_COMPLETED)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_COMPLETED
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'state',
+    [
+        TaskState.TASK_STATE_COMPLETED,
+        TaskState.TASK_STATE_CANCELED,
+        TaskState.TASK_STATE_FAILED,
+        TaskState.TASK_STATE_REJECTED,
+    ],
+)
+async def test_timestamp_validation_failure_allows_terminal_retry(
+    task_updater: TaskUpdater, event_queue: AsyncMock, state: TaskState
+) -> None:
+    with pytest.raises(ValueError):
+        await task_updater.update_status(state, timestamp='not-a-timestamp')
+
+    event_queue.enqueue_event.assert_not_awaited()
+    await task_updater.failed()
+
+    event_queue.enqueue_event.assert_awaited_once()
+    event = event_queue.enqueue_event.call_args.args[0]
+    assert event.status.state == TaskState.TASK_STATE_FAILED
+
+
+@pytest.mark.asyncio
+async def test_metadata_validation_failure_allows_terminal_retry(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    with pytest.raises(ValueError):
+        await task_updater.update_status(
+            TaskState.TASK_STATE_COMPLETED, metadata={'bad': object()}
+        )
+
+    event_queue.enqueue_event.assert_not_awaited()
+    await task_updater.failed()
+
+    event_queue.enqueue_event.assert_awaited_once()
+    event = event_queue.enqueue_event.call_args.args[0]
+    assert event.status.state == TaskState.TASK_STATE_FAILED
+
+
+@pytest.mark.asyncio
+async def test_add_artifact_with_custom_id_and_name(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_parts: list[Part]
+) -> None:
+    """Test adding an artifact with a custom ID and name."""
+    await task_updater.add_artifact(
+        parts=sample_parts,
+        artifact_id='custom-artifact-id',
+        name='Custom Artifact',
+    )
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskArtifactUpdateEvent)
+    assert event.artifact.artifact_id == 'custom-artifact-id'
+    assert event.artifact.name == 'Custom Artifact'
+    assert event.artifact.parts == sample_parts
+
+
+@pytest.mark.asyncio
+async def test_add_artifact_generates_id(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_parts: list[Part]
+) -> None:
+    """Test add_artifact generates an ID if artifact_id is None."""
+    known_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+    with patch('uuid.uuid4', return_value=known_uuid):
+        await task_updater.add_artifact(parts=sample_parts, artifact_id=None)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskArtifactUpdateEvent)
+    assert event.artifact.artifact_id == str(known_uuid)
+    assert event.artifact.parts == sample_parts
+    assert event.append is False
+    assert event.last_chunk is False
+
+
+@pytest.mark.asyncio
+async def test_add_artifact_generates_custom_id(
+    event_queue: AsyncMock, sample_parts: list[Part]
+) -> None:
+    """Test add_artifact uses a custom ID generator when provided."""
+    artifact_id_generator = Mock(spec=IDGenerator)
+    artifact_id_generator.generate.return_value = 'custom-artifact-id'
+    task_updater = TaskUpdater(
+        event_queue=event_queue,
+        task_id='test-task-id',
+        context_id='test-context-id',
+        artifact_id_generator=artifact_id_generator,
+    )
+
+    await task_updater.add_artifact(parts=sample_parts, artifact_id=None)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+    assert isinstance(event, TaskArtifactUpdateEvent)
+    assert event.artifact.artifact_id == 'custom-artifact-id'
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'append_val, last_chunk_val',
+    [
+        (False, False),
+        (True, True),
+        (True, False),
+        (False, True),
+    ],
+)
+async def test_add_artifact_with_append_last_chunk(
+    task_updater: TaskUpdater,
+    event_queue: AsyncMock,
+    sample_parts: list[Part],
+    append_val: bool,
+    last_chunk_val: bool,
+) -> None:
+    """Test add_artifact with append and last_chunk flags."""
+    await task_updater.add_artifact(
+        parts=sample_parts,
+        artifact_id='id1',
+        append=append_val,
+        last_chunk=last_chunk_val,
+    )
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskArtifactUpdateEvent)
+    assert event.artifact.artifact_id == 'id1'
+    assert event.artifact.parts == sample_parts
+    assert event.append == append_val
+    assert event.last_chunk == last_chunk_val
+
+
+@pytest.mark.asyncio
+async def test_complete_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as completed without a message."""
+    await task_updater.complete()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_COMPLETED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_complete_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as completed with a message."""
+    await task_updater.complete(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_COMPLETED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_submit_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as submitted without a message."""
+    await task_updater.submit()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_submit_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as submitted with a message."""
+    await task_updater.submit(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_start_work_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as working without a message."""
+    await task_updater.start_work()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_WORKING
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_start_work_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as working with a message."""
+    await task_updater.start_work(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_WORKING
+    assert event.status.message == sample_message
+
+
+def test_new_agent_message(
+    task_updater: TaskUpdater, sample_parts: list[Part]
+) -> None:
+    """Test creating a new agent message."""
+    with patch(
+        'uuid.uuid4',
+        return_value=uuid.UUID('12345678-1234-5678-1234-567812345678'),
+    ):
+        message = task_updater.new_agent_message(parts=sample_parts)
+
+    assert message.role == Role.ROLE_AGENT
+    assert message.task_id == 'test-task-id'
+    assert message.context_id == 'test-context-id'
+    assert message.message_id == '12345678-1234-5678-1234-567812345678'
+    assert message.parts == sample_parts
+    assert not message.HasField('metadata')
+
+
+def test_new_agent_message_with_metadata(
+    task_updater: TaskUpdater, sample_parts: list[Part]
+) -> None:
+    """Test creating a new agent message with metadata and ."""
+    metadata = {'key': 'value'}
+
+    with patch(
+        'uuid.uuid4',
+        return_value=uuid.UUID('12345678-1234-5678-1234-567812345678'),
+    ):
+        message = task_updater.new_agent_message(
+            parts=sample_parts, metadata=metadata
+        )
+
+    assert message.role == Role.ROLE_AGENT
+    assert message.task_id == 'test-task-id'
+    assert message.context_id == 'test-context-id'
+    assert message.message_id == '12345678-1234-5678-1234-567812345678'
+    assert message.parts == sample_parts
+    assert message.metadata == metadata
+
+
+def test_new_agent_message_with_custom_id_generator(
+    event_queue: AsyncMock, sample_parts: list[Part]
+) -> None:
+    """Test creating a new agent message with a custom message ID generator."""
+    message_id_generator = Mock(spec=IDGenerator)
+    message_id_generator.generate.return_value = 'custom-message-id'
+    task_updater = TaskUpdater(
+        event_queue=event_queue,
+        task_id='test-task-id',
+        context_id='test-context-id',
+        message_id_generator=message_id_generator,
+    )
+
+    message = task_updater.new_agent_message(parts=sample_parts)
+
+    assert message.message_id == 'custom-message-id'
+
+
+@pytest.mark.asyncio
+async def test_failed_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as failed without a message."""
+    await task_updater.failed()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_FAILED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_failed_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as failed with a message."""
+    await task_updater.failed(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_FAILED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_reject_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as rejected without a message."""
+    await task_updater.reject()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_REJECTED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_reject_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as rejected with a message."""
+    await task_updater.reject(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_REJECTED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_requires_input_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as input required without a message."""
+    await task_updater.requires_input()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_requires_input_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as input required with a message."""
+    await task_updater.requires_input(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_requires_input_final_true(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as input required with ."""
+    await task_updater.requires_input()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_requires_input_with_message_and_final(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as input required with message and ."""
+    await task_updater.requires_input(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_INPUT_REQUIRED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_requires_auth_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as auth required without a message."""
+    await task_updater.requires_auth()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_requires_auth_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as auth required with a message."""
+    await task_updater.requires_auth(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_requires_auth_final_true(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as auth required with ."""
+    await task_updater.requires_auth()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_requires_auth_with_message_and_final(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as auth required with message and ."""
+    await task_updater.requires_auth(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_AUTH_REQUIRED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_cancel_without_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    """Test marking a task as cancelled without a message."""
+    await task_updater.cancel()
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_CANCELED
+    assert not event.status.HasField('message')
+
+
+@pytest.mark.asyncio
+async def test_cancel_with_message(
+    task_updater: TaskUpdater, event_queue: AsyncMock, sample_message: Message
+) -> None:
+    """Test marking a task as cancelled with a message."""
+    await task_updater.cancel(message=sample_message)
+
+    event_queue.enqueue_event.assert_called_once()
+    event = event_queue.enqueue_event.call_args[0][0]
+
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state == TaskState.TASK_STATE_CANCELED
+    assert event.status.message == sample_message
+
+
+@pytest.mark.asyncio
+async def test_update_status_raises_error_if_terminal_state_reached(
+    task_updater: TaskUpdater, event_queue: AsyncMock
+) -> None:
+    await task_updater.complete()
+    event_queue.reset_mock()
+    with pytest.raises(RuntimeError):
+        await task_updater.start_work()
+    event_queue.enqueue_event.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_concurrent_updates_race_condition(
+    event_queue: AsyncMock,
+) -> None:
+    task_updater = TaskUpdater(
+        event_queue=event_queue,
+        task_id='test-task-id',
+        context_id='test-context-id',
+    )
+    tasks = [
+        task_updater.complete(),
+        task_updater.failed(),
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    successes = [r for r in results if not isinstance(r, Exception)]
+    failures = [r for r in results if isinstance(r, RuntimeError)]
+    assert len(successes) == 1
+    assert len(failures) == 1
+    assert event_queue.enqueue_event.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_reject_concurrently_with_complete(
+    event_queue: AsyncMock,
+) -> None:
+    """Test for race conditions when reject and complete are called concurrently."""
+    task_updater = TaskUpdater(
+        event_queue=event_queue,
+        task_id='concurrent-task',
+        context_id='concurrent-context',
+    )
+
+    tasks = [
+        task_updater.reject(),
+        task_updater.complete(),
+    ]
+
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    successes = [r for r in results if not isinstance(r, Exception)]
+    failures = [r for r in results if isinstance(r, RuntimeError)]
+
+    assert len(successes) == 1
+    assert len(failures) == 1
+
+    assert event_queue.enqueue_event.call_count == 1
+
+    event = event_queue.enqueue_event.call_args[0][0]
+    assert isinstance(event, TaskStatusUpdateEvent)
+    assert event.status.state in [
+        TaskState.TASK_STATE_REJECTED,
+        TaskState.TASK_STATE_COMPLETED,
+    ]
diff --git a/tests/server/test_cross_event_loop_locks.py b/tests/server/test_cross_event_loop_locks.py
new file mode 100644
index 000000000..edbac80d7
--- /dev/null
+++ b/tests/server/test_cross_event_loop_locks.py
@@ -0,0 +1,260 @@
+"""Regression tests: in-memory server singletons are safe across event loops."""
+
+import asyncio
+import threading
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from a2a.server.agent_execution.active_task_registry import ActiveTaskRegistry
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.server.request_handlers.default_request_handler import (
+    LegacyRequestHandler,
+)
+from a2a.server.tasks.inmemory_push_notification_config_store import (
+    InMemoryPushNotificationConfigStore,
+)
+from a2a.server.tasks.inmemory_task_store import _InMemoryTaskStoreImpl
+
+
+_RLOCK_TYPE = type(threading.RLock())
+
+
+class _PersistentLoop:
+    """An asyncio event loop running forever on its own daemon thread."""
+
+    def __init__(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def _run(self) -> None:
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_forever()
+
+    def run(self, coro, timeout: float = 10):
+        """Runs coro to completion on this loop and returns its result."""
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result(
+            timeout=timeout
+        )
+
+    def close(self) -> None:
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join(timeout=10)
+
+
+@pytest.fixture
+def two_loops():
+    loop_a = _PersistentLoop()
+    loop_b = _PersistentLoop()
+    try:
+        yield loop_a, loop_b
+    finally:
+        loop_a.close()
+        loop_b.close()
+
+
+# --- deterministic invariant: the guard is a threading lock, not asyncio ---
+
+
+def test_queue_manager_lock_is_threading_lock() -> None:
+    manager = InMemoryQueueManager()
+    assert not isinstance(manager._lock, asyncio.Lock)
+    assert isinstance(manager._lock, _RLOCK_TYPE)
+
+
+def test_active_task_registry_lock_is_threading_lock() -> None:
+    registry = ActiveTaskRegistry(
+        agent_executor=MagicMock(), task_store=MagicMock()
+    )
+    assert not isinstance(registry._lock, asyncio.Lock)
+    assert isinstance(registry._lock, _RLOCK_TYPE)
+
+
+def test_inmemory_task_store_lock_is_threading_lock() -> None:
+    store = _InMemoryTaskStoreImpl()
+    assert not isinstance(store.lock, asyncio.Lock)
+    assert isinstance(store.lock, _RLOCK_TYPE)
+
+
+def test_push_config_store_lock_is_threading_lock() -> None:
+    store = InMemoryPushNotificationConfigStore()
+    assert not isinstance(store.lock, asyncio.Lock)
+    assert isinstance(store.lock, _RLOCK_TYPE)
+
+
+def test_request_handler_running_agents_lock_is_threading_lock() -> None:
+    handler = LegacyRequestHandler(MagicMock(), MagicMock(), MagicMock())
+    assert not isinstance(handler._running_agents_lock, asyncio.Lock)
+    assert isinstance(handler._running_agents_lock, _RLOCK_TYPE)
+
+
+# --- functional: the real objects work when driven from two event loops ---
+
+
+def test_queue_manager_across_event_loops(two_loops) -> None:
+    loop_a, loop_b = two_loops
+    manager = InMemoryQueueManager()
+
+    # Task 1 is created on loop A (the first loop to touch the manager's guard).
+    loop_a.run(manager.create_or_tap('task-1'))
+
+    # Task 2 is created on loop B, and task 1 is tapped/closed from loop B --
+    # exercising the shared guard from a different loop than created it.
+    assert loop_b.run(manager.create_or_tap('task-2')) is not None
+    assert loop_b.run(manager.tap('task-1')) is not None
+    assert loop_a.run(manager.get('task-2')) is not None
+    loop_b.run(manager.close('task-1'))
+    assert loop_a.run(manager.get('task-1')) is None
+
+
+def test_push_config_store_across_event_loops(two_loops) -> None:
+    loop_a, loop_b = two_loops
+    store = InMemoryPushNotificationConfigStore()
+
+    # get_info_for_dispatch takes no ServerCallContext, so it exercises the
+    # guard directly from each loop.
+    assert loop_a.run(store.get_info_for_dispatch('task-1')) == []
+    assert loop_b.run(store.get_info_for_dispatch('task-1')) == []
+
+
+def test_queue_manager_interleaved_across_loops(two_loops) -> None:
+    loop_a, loop_b = two_loops
+    manager = InMemoryQueueManager()
+    for i in range(10):
+        loop = loop_a if i % 2 == 0 else loop_b
+        loop.run(manager.create_or_tap(f'task-{i}'))
+    for i in range(10):
+        # Read each task from the opposite loop that created it.
+        loop = loop_b if i % 2 == 0 else loop_a
+        assert loop.run(manager.get(f'task-{i}')) is not None
+
+
+# --- contended acquisition across loops (deterministic; the discriminator) ---
+
+
+def _contended_acquire(lock, two_loops) -> None:
+    """Holds ``lock`` on loop A while loop B acquires it (a genuinely contended
+    cross-loop acquisition). With an ``asyncio.Lock`` this raises
+    ``RuntimeError: bound to a different event loop`` (or deadlocks); with a
+    ``threading.RLock`` it serializes and completes."""
+    loop_a, loop_b = two_loops
+    a_holds = threading.Event()
+    b_queued = threading.Event()
+
+    async def holder() -> None:
+        lock.acquire()
+        try:
+            a_holds.set()
+            b_queued.wait(3)
+        finally:
+            lock.release()
+
+    async def contender() -> None:
+        a_holds.wait(3)
+        b_queued.set()
+        # Acquire on loop B's thread without freezing the loop.
+        await asyncio.get_event_loop().run_in_executor(
+            None, _acquire_release, lock
+        )
+
+    fut_a = asyncio.run_coroutine_threadsafe(holder(), loop_a._loop)
+    fut_b = asyncio.run_coroutine_threadsafe(contender(), loop_b._loop)
+    fut_b.result(timeout=5)
+    fut_a.result(timeout=5)
+
+
+def _acquire_release(lock) -> None:
+    lock.acquire()
+    lock.release()
+
+
+def test_queue_manager_lock_contended_across_loops(two_loops) -> None:
+    _contended_acquire(InMemoryQueueManager()._lock, two_loops)
+
+
+def test_task_store_lock_contended_across_loops(two_loops) -> None:
+    _contended_acquire(_InMemoryTaskStoreImpl().lock, two_loops)
+
+
+def test_active_task_registry_lock_contended_across_loops(two_loops) -> None:
+    registry = ActiveTaskRegistry(
+        agent_executor=MagicMock(), task_store=MagicMock()
+    )
+    _contended_acquire(registry._lock, two_loops)
+
+
+# --- end-to-end: on_message_send driven from two loops through v2 handler ---
+
+
+def test_on_message_send_across_event_loops(two_loops) -> None:
+    """Drive the real request handler's ``on_message_send`` for two task ids
+    concurrently on two event loops sharing one handler + one task store."""
+    import uuid
+
+    from a2a.auth.user import UnauthenticatedUser
+    from a2a.helpers.proto_helpers import new_task_from_user_message
+    from a2a.server.agent_execution import AgentExecutor
+    from a2a.server.context import ServerCallContext
+    from a2a.server.request_handlers.default_request_handler_v2 import (
+        DefaultRequestHandlerV2,
+    )
+    from a2a.server.tasks import InMemoryTaskStore, TaskUpdater
+    from a2a.types import (
+        AgentCapabilities,
+        AgentCard,
+        Message,
+        Part,
+        Role,
+        SendMessageRequest,
+        TaskState,
+    )
+
+    class _CompletingAgent(AgentExecutor):
+        async def execute(self, context, event_queue) -> None:
+            if context.message:
+                await event_queue.enqueue_event(
+                    new_task_from_user_message(context.message)
+                )
+            updater = TaskUpdater(
+                event_queue,
+                task_id=context.task_id or str(uuid.uuid4()),
+                context_id=context.context_id or str(uuid.uuid4()),
+            )
+            await updater.update_status(TaskState.TASK_STATE_WORKING)
+            await updater.complete()
+
+        async def cancel(self, context, event_queue) -> None:
+            raise NotImplementedError
+
+    loop_a, loop_b = two_loops
+    handler = DefaultRequestHandlerV2(
+        _CompletingAgent(),
+        InMemoryTaskStore(),
+        AgentCard(
+            name='test_agent',
+            version='1.0',
+            capabilities=AgentCapabilities(streaming=True),
+        ),
+    )
+    ctx = ServerCallContext(user=UnauthenticatedUser())
+
+    def req(mid: str) -> SendMessageRequest:
+        return SendMessageRequest(
+            message=Message(
+                role=Role.ROLE_USER, message_id=mid, parts=[Part(text='hi')]
+            )
+        )
+
+    # Two requests genuinely in-flight on two loops against the same handler.
+    fut_a = asyncio.run_coroutine_threadsafe(
+        handler.on_message_send(req('a1'), ctx), loop_a._loop
+    )
+    fut_b = asyncio.run_coroutine_threadsafe(
+        handler.on_message_send(req('b1'), ctx), loop_b._loop
+    )
+    task_a = fut_a.result(timeout=15)
+    task_b = fut_b.result(timeout=15)
+    assert task_a.status.state == TaskState.TASK_STATE_COMPLETED
+    assert task_b.status.state == TaskState.TASK_STATE_COMPLETED
diff --git a/tests/server/test_integration.py b/tests/server/test_integration.py
new file mode 100644
index 000000000..c82fd6c99
--- /dev/null
+++ b/tests/server/test_integration.py
@@ -0,0 +1,953 @@
+import asyncio
+
+from unittest import mock
+
+import pytest
+
+from a2a.server.jsonrpc_models import (
+    InternalError,
+    InvalidParamsError,
+    InvalidRequestError,
+    JSONParseError,
+    MethodNotFoundError,
+)
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.types import (
+    UnsupportedOperationError,
+)
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    Artifact,
+    Message,
+    Part,
+    Role,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskPushNotificationConfig,
+    TaskState,
+    TaskStatus,
+)
+from a2a.utils import (
+    AGENT_CARD_WELL_KNOWN_PATH,
+)
+from starlette.authentication import (
+    AuthCredentials,
+    AuthenticationBackend,
+    BaseUser,
+    SimpleUser,
+)
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.requests import HTTPConnection
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+
+# === TEST SETUP ===
+
+MINIMAL_AGENT_SKILL = AgentSkill(
+    id='skill-123',
+    name='Recipe Finder',
+    description='Finds recipes',
+    tags=['cooking'],
+)
+
+AGENT_CAPS = AgentCapabilities(push_notifications=True, streaming=True)
+
+MINIMAL_AGENT_CARD_DATA = AgentCard(
+    capabilities=AGENT_CAPS,
+    default_input_modes=['text/plain'],
+    default_output_modes=['application/json'],
+    description='Test Agent',
+    name='TestAgent',
+    skills=[MINIMAL_AGENT_SKILL],
+    supported_interfaces=[
+        AgentInterface(
+            url='http://example.com/agent', protocol_binding='HTTP+JSON'
+        )
+    ],
+    version='1.0',
+)
+
+EXTENDED_AGENT_SKILL = AgentSkill(
+    id='skill-extended',
+    name='Extended Skill',
+    description='Does more things',
+    tags=['extended'],
+)
+
+EXTENDED_AGENT_CARD_DATA = AgentCard(
+    capabilities=AGENT_CAPS,
+    default_input_modes=['text/plain'],
+    default_output_modes=['application/json'],
+    description='Test Agent with more details',
+    name='TestAgent Extended',
+    skills=[MINIMAL_AGENT_SKILL, EXTENDED_AGENT_SKILL],
+    supported_interfaces=[
+        AgentInterface(
+            url='http://example.com/agent', protocol_binding='HTTP+JSON'
+        )
+    ],
+    version='1.0',
+)
+from google.protobuf.struct_pb2 import Struct, Value
+
+
+TEXT_PART_DATA = Part(text='Hello')
+
+# For proto, Part.data takes a Value(struct_value=Struct)
+_struct = Struct()
+_struct.update({'key': 'value'})
+DATA_PART = Part(data=Value(struct_value=_struct))
+
+MINIMAL_MESSAGE_USER = Message(
+    role=Role.ROLE_USER,
+    parts=[TEXT_PART_DATA],
+    message_id='msg-123',
+)
+
+MINIMAL_TASK_STATUS = TaskStatus(state=TaskState.TASK_STATE_SUBMITTED)
+
+FULL_TASK_STATUS = TaskStatus(
+    state=TaskState.TASK_STATE_WORKING,
+    message=MINIMAL_MESSAGE_USER,
+)
+
+
+@pytest.fixture
+def agent_card():
+    return MINIMAL_AGENT_CARD_DATA
+
+
+@pytest.fixture
+def extended_agent_card_fixture():
+    return EXTENDED_AGENT_CARD_DATA
+
+
+@pytest.fixture
+def handler():
+    handler = mock.AsyncMock()
+    handler.on_message_send = mock.AsyncMock()
+    handler.on_cancel_task = mock.AsyncMock()
+    handler.on_get_task = mock.AsyncMock()
+    handler.set_push_notification = mock.AsyncMock()
+    handler.get_push_notification = mock.AsyncMock()
+    handler.on_message_send_stream = mock.Mock()
+    handler.on_subscribe_to_task = mock.Mock()
+    return handler
+
+
+class AppBuilder:
+    def __init__(self, agent_card, handler, card_modifier=None):
+        self.agent_card = agent_card
+        self.handler = handler
+        self.card_modifier = card_modifier
+
+    def build(
+        self,
+        rpc_url='/',
+        agent_card_url=AGENT_CARD_WELL_KNOWN_PATH,
+        middleware=None,
+        routes=None,
+    ):
+        from starlette.applications import Starlette
+
+        app_instance = Starlette(middleware=middleware, routes=routes or [])
+
+        # Agent card router
+        card_routes = create_agent_card_routes(
+            self.agent_card,
+            card_url=agent_card_url,
+            card_modifier=self.card_modifier,
+        )
+        app_instance.routes.extend(card_routes)
+
+        # JSON-RPC router
+        rpc_routes = create_jsonrpc_routes(self.handler, rpc_url=rpc_url)
+        app_instance.routes.extend(rpc_routes)
+
+        return app_instance
+
+
+@pytest.fixture
+def app(agent_card: AgentCard, handler: mock.AsyncMock):
+    return AppBuilder(agent_card, handler)
+
+
+@pytest.fixture
+def client(app, **kwargs):
+    """Create a test client with the app builder."""
+    return TestClient(app.build(**kwargs), headers={'A2A-Version': '1.0'})
+
+
+# === BASIC FUNCTIONALITY TESTS ===
+
+
+def test_agent_card_endpoint(client: TestClient, agent_card: AgentCard):
+    """Test the agent card endpoint returns expected data."""
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == agent_card.name
+    assert data['version'] == agent_card.version
+    assert 'streaming' in data['capabilities']
+
+
+def test_agent_card_custom_url(app, agent_card: AgentCard):
+    """Test the agent card endpoint with a custom URL."""
+    client = TestClient(app.build(agent_card_url='/my-agent'))
+    response = client.get('/my-agent')
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == agent_card.name
+
+
+def test_starlette_rpc_endpoint_custom_url(app, handler: mock.AsyncMock):
+    """Test the RPC endpoint with a custom URL."""
+    # Provide a valid Task object as the return value
+    task_status = MINIMAL_TASK_STATUS
+    task = Task(id='task1', context_id='ctx1', status=task_status)
+    handler.on_get_task.return_value = task
+    client = TestClient(
+        app.build(rpc_url='/api/rpc'), headers={'A2A-Version': '1.0'}
+    )
+    response = client.post(
+        '/api/rpc',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTask',
+            'params': {'id': 'task1'},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['id'] == 'task1'
+
+
+def test_fastapi_rpc_endpoint_custom_url(app, handler: mock.AsyncMock):
+    """Test the RPC endpoint with a custom URL."""
+    # Provide a valid Task object as the return value
+    task_status = MINIMAL_TASK_STATUS
+    task = Task(id='task1', context_id='ctx1', status=task_status)
+    handler.on_get_task.return_value = task
+    client = TestClient(
+        app.build(rpc_url='/api/rpc'), headers={'A2A-Version': '1.0'}
+    )
+    response = client.post(
+        '/api/rpc',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTask',
+            'params': {'id': 'task1'},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['id'] == 'task1'
+
+
+def test_starlette_build_with_extra_routes(app, agent_card: AgentCard):
+    """Test building the app with additional routes."""
+
+    def custom_handler(request):
+        return JSONResponse({'message': 'Hello'})
+
+    extra_route = Route('/hello', custom_handler, methods=['GET'])
+    test_app = app.build(routes=[extra_route])
+    client = TestClient(test_app, headers={'A2A-Version': '1.0'})
+
+    # Test the added route
+    response = client.get('/hello')
+    assert response.status_code == 200
+    assert response.json() == {'message': 'Hello'}
+
+    # Ensure default routes still work
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == agent_card.name
+
+
+def test_fastapi_build_with_extra_routes(app, agent_card: AgentCard):
+    """Test building the app with additional routes."""
+
+    def custom_handler(request):
+        return JSONResponse({'message': 'Hello'})
+
+    extra_route = Route('/hello', custom_handler, methods=['GET'])
+    test_app = app.build(routes=[extra_route])
+    client = TestClient(test_app)
+
+    # Test the added route
+    response = client.get('/hello')
+    assert response.status_code == 200
+    assert response.json() == {'message': 'Hello'}
+
+    # Ensure default routes still work
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == agent_card.name
+
+
+def test_fastapi_build_custom_agent_card_path(app, agent_card: AgentCard):
+    """Test building the app with a custom agent card path."""
+
+    test_app = app.build(agent_card_url='/agent-card')
+    client = TestClient(test_app)
+
+    # Ensure custom card path works
+    response = client.get('/agent-card')
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == agent_card.name
+
+    # Ensure default path returns 404
+    default_response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert default_response.status_code == 404
+
+
+# === REQUEST METHODS TESTS ===
+
+
+def test_send_message(client: TestClient, handler: mock.AsyncMock):
+    """Test sending a message."""
+    # Prepare mock response
+    task_status = MINIMAL_TASK_STATUS
+    mock_task = Task(
+        id='task1',
+        context_id='session-xyz',
+        status=task_status,
+    )
+    handler.on_message_send.return_value = mock_task
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'SendMessage',
+            'params': {
+                'message': {
+                    'role': 'ROLE_AGENT',
+                    'parts': [{'text': 'Hello'}],
+                    'messageId': '111',
+                    'taskId': 'task1',
+                    'contextId': 'session-xyz',
+                }
+            },
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert 'result' in data
+    # Result is wrapped in SendMessageResponse with task field
+    assert data['result']['task']['id'] == 'task1'
+    assert data['result']['task']['status']['state'] == 'TASK_STATE_SUBMITTED'
+
+    # Verify handler was called
+    handler.on_message_send.assert_awaited_once()
+
+
+def test_cancel_task(client: TestClient, handler: mock.AsyncMock):
+    """Test cancelling a task."""
+    # Setup mock response
+    task_status = MINIMAL_TASK_STATUS
+    task_status.state = TaskState.TASK_STATE_CANCELED  # 'cancelled' #
+    task = Task(id='task1', context_id='ctx1', status=task_status)
+    handler.on_cancel_task.return_value = task
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'CancelTask',
+            'params': {'id': 'task1'},
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['id'] == 'task1'
+    assert data['result']['status']['state'] == 'TASK_STATE_CANCELED'
+
+    # Verify handler was called
+    handler.on_cancel_task.assert_awaited_once()
+
+
+def test_get_task(client: TestClient, handler: mock.AsyncMock):
+    """Test getting a task."""
+    # Setup mock response
+    task_status = MINIMAL_TASK_STATUS
+    task = Task(id='task1', context_id='ctx1', status=task_status)
+    handler.on_get_task.return_value = task  # JSONRPCResponse(root=task)
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTask',
+            'params': {'id': 'task1'},
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['id'] == 'task1'
+
+    # Verify handler was called
+    handler.on_get_task.assert_awaited_once()
+
+
+def test_set_push_notification_config(
+    client: TestClient, handler: mock.AsyncMock
+):
+    """Test setting push notification configuration."""
+    # Setup mock response
+    task_push_config = TaskPushNotificationConfig(
+        task_id='t2', url='https://example.com', token='secret-token'
+    )
+    handler.on_create_task_push_notification_config.return_value = (
+        task_push_config
+    )
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'CreateTaskPushNotificationConfig',
+            'params': {
+                'task_id': 't2',
+                'url': 'https://example.com',
+                'token': 'secret-token',
+            },
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['token'] == 'secret-token'
+
+    # Verify handler was called
+    handler.on_create_task_push_notification_config.assert_awaited_once()
+
+
+def test_get_push_notification_config(
+    client: TestClient, handler: mock.AsyncMock
+):
+    """Test getting push notification configuration."""
+    # Setup mock response
+    task_push_config = TaskPushNotificationConfig(
+        task_id='task1', url='https://example.com', token='secret-token'
+    )
+
+    handler.on_get_task_push_notification_config.return_value = task_push_config
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTaskPushNotificationConfig',
+            'params': {
+                'task_id': 'task1',
+                'id': 'pushNotificationConfig',
+            },
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert data['result']['token'] == 'secret-token'
+
+    # Verify handler was called
+    handler.on_get_task_push_notification_config.assert_awaited_once()
+
+
+def test_server_auth(app, handler: mock.AsyncMock):
+    class TestAuthMiddleware(AuthenticationBackend):
+        async def authenticate(
+            self, conn: HTTPConnection
+        ) -> tuple[AuthCredentials, BaseUser] | None:
+            # For the purposes of this test, all requests are authenticated!
+            return (AuthCredentials(['authenticated']), SimpleUser('test_user'))
+
+    client = TestClient(
+        app.build(
+            middleware=[
+                Middleware(
+                    AuthenticationMiddleware, backend=TestAuthMiddleware()
+                )
+            ]
+        ),
+        headers={'A2A-Version': '1.0'},
+    )
+
+    # Set the output message to be the authenticated user name
+    handler.on_message_send.side_effect = lambda params, context: Message(
+        context_id='session-xyz',
+        message_id='112',
+        role=Role.ROLE_AGENT,
+        parts=[
+            Part(text=context.user.user_name),
+        ],
+    )
+
+    # Send request
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'SendMessage',
+            'params': {
+                'message': {
+                    'role': 'ROLE_AGENT',
+                    'parts': [{'text': 'Hello'}],
+                    'messageId': '111',
+                    'taskId': 'task1',
+                    'contextId': 'session-xyz',
+                }
+            },
+        },
+    )
+
+    # Verify response
+    assert response.status_code == 200
+    data = response.json()
+    assert 'result' in data
+    # Result is wrapped in SendMessageResponse with message field
+    assert data['result']['message']['parts'][0]['text'] == 'test_user'
+
+    # Verify handler was called
+    handler.on_message_send.assert_awaited_once()
+
+
+# === STREAMING TESTS ===
+
+
+@pytest.mark.asyncio
+async def test_message_send_stream(app, handler: mock.AsyncMock) -> None:
+    """Test streaming message sending."""
+
+    # Setup mock streaming response
+    async def stream_generator():
+        for i in range(3):
+            artifact = Artifact(
+                artifact_id=f'artifact-{i}',
+                name='result_data',
+                parts=[TEXT_PART_DATA, DATA_PART],
+            )
+            last = [False, False, True]
+            yield TaskArtifactUpdateEvent(
+                artifact=artifact,
+                task_id='task_id',
+                context_id='session-xyz',
+                append=False,
+                last_chunk=last[i],
+            )
+
+    handler.on_message_send_stream.return_value = stream_generator()
+
+    client = None
+    try:
+        # Create client
+        client = TestClient(
+            app.build(),
+            raise_server_exceptions=False,
+            headers={'A2A-Version': '1.0'},
+        )
+        # Send request
+        with client.stream(
+            'POST',
+            '/',
+            json={
+                'jsonrpc': '2.0',
+                'id': '123',
+                'method': 'SendStreamingMessage',
+                'params': {
+                    'message': {
+                        'role': 'ROLE_AGENT',
+                        'parts': [{'text': 'Hello'}],
+                        'messageId': '111',
+                        'taskId': 'task_id',
+                        'contextId': 'session-xyz',
+                    }
+                },
+            },
+        ) as response:
+            # Verify response is a stream
+            assert response.status_code == 200
+            assert response.headers['content-type'].startswith(
+                'text/event-stream'
+            )
+
+            # Read some content to verify streaming works
+            content = b''
+            event_count = 0
+
+            for chunk in response.iter_bytes():
+                content += chunk
+                if b'data' in chunk:  # Naive check for SSE data lines
+                    event_count += 1
+
+            # Check content has event data (e.g., part of the first event)
+            assert b'artifact-0' in content  # Check for the actual JSON payload
+            assert b'artifact-1' in content  # Check for the actual JSON payload
+            assert b'artifact-2' in content  # Check for the actual JSON payload
+            assert event_count > 0
+    finally:
+        # Ensure the client is closed
+        if client:
+            client.close()
+        # Allow event loop to process any pending callbacks
+        await asyncio.sleep(0.1)
+
+
+@pytest.mark.asyncio
+async def test_task_resubscription(app, handler: mock.AsyncMock) -> None:
+    """Test task resubscription streaming."""
+
+    # Setup mock streaming response
+    async def stream_generator():
+        for i in range(3):
+            artifact = Artifact(
+                artifact_id=f'artifact-{i}',
+                name='result_data',
+                parts=[TEXT_PART_DATA, DATA_PART],
+            )
+            last = [False, False, True]
+            yield TaskArtifactUpdateEvent(
+                artifact=artifact,
+                task_id='task_id',
+                context_id='session-xyz',
+                append=False,
+                last_chunk=last[i],
+            )
+
+    handler.on_subscribe_to_task.return_value = stream_generator()
+
+    # Create client
+    client = TestClient(
+        app.build(),
+        raise_server_exceptions=False,
+        headers={'A2A-Version': '1.0'},
+    )
+
+    try:
+        # Send request using client.stream() context manager
+        # Send request
+        with client.stream(
+            'POST',
+            '/',
+            json={
+                'jsonrpc': '2.0',
+                'id': '123',  # This ID is used in the success_event above
+                'method': 'SubscribeToTask',
+                'params': {'id': 'task1'},
+            },
+        ) as response:
+            # Verify response is a stream
+            assert response.status_code == 200
+            assert (
+                response.headers['content-type']
+                == 'text/event-stream; charset=utf-8'
+            )
+
+            # Read some content to verify streaming works
+            content = b''
+            event_count = 0
+            for chunk in response.iter_bytes():
+                content += chunk
+                # A more robust check would be to parse each SSE event
+                if b'data:' in chunk:  # Naive check for SSE data lines
+                    event_count += 1
+
+            # Check content has event data (e.g., part of the first event)
+            assert b'artifact-0' in content  # Check for the actual JSON payload
+            assert b'artifact-1' in content  # Check for the actual JSON payload
+            assert b'artifact-2' in content  # Check for the actual JSON payload
+            assert event_count > 0
+    finally:
+        # Ensure the client is closed
+        if client:
+            client.close()
+        # Allow event loop to process any pending callbacks
+        await asyncio.sleep(0.1)
+
+
+# === ERROR HANDLING TESTS ===
+
+
+def test_invalid_json(client: TestClient):
+    """Test handling invalid JSON."""
+    response = client.post('/', content=b'This is not JSON')  # Use bytes
+    assert response.status_code == 200  # JSON-RPC errors still return 200
+    data = response.json()
+    assert 'error' in data
+    assert data['error']['code'] == JSONParseError().code
+
+
+def test_invalid_request_structure(client: TestClient):
+    """Test handling an invalid request structure."""
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': 'aaaa',  # Missing or wrong required fields
+            'id': '123',
+            'method': 'foo/bar',
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    # The jsonrpc library returns InvalidRequestError for invalid requests format
+    assert data['error']['code'] == InvalidRequestError().code
+
+
+def test_invalid_request_method(client: TestClient):
+    """Test handling an invalid request method."""
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',  # Missing or wrong required fields
+            'id': '123',
+            'method': 'foo/bar',
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    # The jsonrpc library returns MethodNotFoundError for invalid request method
+    assert data['error']['code'] == MethodNotFoundError().code
+
+
+# === DYNAMIC CARD MODIFIER TESTS ===
+
+
+def test_dynamic_agent_card_modifier(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that the card_modifier dynamically alters the public agent card."""
+
+    async def modifier(card: AgentCard) -> AgentCard:
+        modified_card = AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Dynamically Modified Agent'
+        return modified_card
+
+    app_instance = AppBuilder(agent_card, handler, card_modifier=modifier)
+    client = TestClient(app_instance.build())
+
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == 'Dynamically Modified Agent'
+    assert (
+        data['version'] == agent_card.version
+    )  # Ensure other fields are intact
+
+
+def test_dynamic_agent_card_modifier_sync(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that a synchronous card_modifier dynamically alters the public agent card."""
+
+    async def modifier(card: AgentCard) -> AgentCard:
+        modified_card = AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Dynamically Modified Agent'
+        return modified_card
+
+    app_instance = AppBuilder(agent_card, handler, card_modifier=modifier)
+    client = TestClient(app_instance.build())
+
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == 'Dynamically Modified Agent'
+    assert (
+        data['version'] == agent_card.version
+    )  # Ensure other fields are intact
+
+
+def test_fastapi_dynamic_agent_card_modifier(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that the card_modifier dynamically alters the public agent card for FastAPI."""
+
+    async def modifier(card: AgentCard) -> AgentCard:
+        modified_card = AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Dynamically Modified Agent'
+        return modified_card
+
+    app_instance = AppBuilder(agent_card, handler, card_modifier=modifier)
+    client = TestClient(app_instance.build())
+
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == 'Dynamically Modified Agent'
+
+
+def test_fastapi_dynamic_agent_card_modifier_sync(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that a synchronous card_modifier dynamically alters the public agent card for FastAPI."""
+
+    async def modifier(card: AgentCard) -> AgentCard:
+        modified_card = AgentCard()
+        modified_card.CopyFrom(card)
+        modified_card.name = 'Dynamically Modified Agent'
+        return modified_card
+
+    app_instance = AppBuilder(agent_card, handler, card_modifier=modifier)
+    client = TestClient(app_instance.build())
+
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data['name'] == 'Dynamically Modified Agent'
+
+
+def test_unsupported_operation_error(
+    client: TestClient, handler: mock.AsyncMock
+):
+    """Test handling UnsupportedOperationError."""
+    handler.on_get_task.side_effect = UnsupportedOperationError()
+
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTask',
+            'params': {'id': 'task1'},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    assert data['error']['code'] == -32004  # UnsupportedOperationError
+
+
+def test_unknown_method(client: TestClient):
+    """Test handling unknown method."""
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'unknown/method',
+            'params': {},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    # This should produce an UnsupportedOperationError error code
+    assert data['error']['code'] == MethodNotFoundError().code
+
+
+def test_validation_error(client: TestClient):
+    """Test handling validation error."""
+    # A params the dispatcher cannot parse at all. Merely omitting required
+    # fields no longer stops here: the unknown names are dropped, leaving an
+    # empty Message that the handler's required-field validation rejects
+    # instead -- a layer this mock handler never reaches.
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'SendMessage',
+            'params': {'message': {'parts': 'should be a list'}},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    assert data['error']['code'] == InvalidParamsError().code
+
+
+def test_unhandled_exception(client: TestClient, handler: mock.AsyncMock):
+    """Test handling unhandled exception."""
+    handler.on_get_task.side_effect = Exception('Unexpected error')
+
+    response = client.post(
+        '/',
+        json={
+            'jsonrpc': '2.0',
+            'id': '123',
+            'method': 'GetTask',
+            'params': {'id': 'task1'},
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    assert data['error']['code'] == InternalError().code
+    assert 'Unexpected error' in data['error']['message']
+
+
+def test_get_method_to_rpc_endpoint(client: TestClient):
+    """Test sending GET request to RPC endpoint."""
+    response = client.get('/')
+    # Should return 405 Method Not Allowed
+    assert response.status_code == 405
+
+
+def test_non_dict_json(client: TestClient):
+    """Test handling JSON that's not a dict."""
+    response = client.post('/', json=['not', 'a', 'dict'])
+    assert response.status_code == 200
+    data = response.json()
+    assert 'error' in data
+    assert data['error']['code'] == InvalidRequestError().code
+
+
+def test_agent_card_backward_compatibility_supports_extended_card(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that supportsAuthenticatedExtendedCard is injected when extended_agent_card is True."""
+    agent_card.capabilities.extended_agent_card = True
+    app_instance = AppBuilder(agent_card, handler)
+    client = TestClient(app_instance.build())
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert data.get('supportsAuthenticatedExtendedCard') is True
+
+
+def test_agent_card_backward_compatibility_no_extended_card(
+    agent_card: AgentCard, handler: mock.AsyncMock
+):
+    """Test that supportsAuthenticatedExtendedCard is absent when extended_agent_card is False."""
+    agent_card.capabilities.extended_agent_card = False
+    app_instance = AppBuilder(agent_card, handler)
+    client = TestClient(app_instance.build())
+    response = client.get(AGENT_CARD_WELL_KNOWN_PATH)
+    assert response.status_code == 200
+    data = response.json()
+    assert 'supportsAuthenticatedExtendedCard' not in data
diff --git a/tests/server/test_models.py b/tests/server/test_models.py
new file mode 100644
index 000000000..46b0199d3
--- /dev/null
+++ b/tests/server/test_models.py
@@ -0,0 +1,46 @@
+"""Tests for a2a.server.models module."""
+
+from a2a.server.models import (
+    create_push_notification_config_model,
+    create_task_model,
+)
+from sqlalchemy.orm import DeclarativeBase
+
+
+def test_create_task_model():
+    """Test dynamic task model creation."""
+
+    # Create a fresh base to avoid table conflicts
+    class TestBase(DeclarativeBase):
+        pass
+
+    # Create with default table name
+    default_task_model = create_task_model('test_tasks_1', TestBase)
+    assert default_task_model.__tablename__ == 'test_tasks_1'
+    assert default_task_model.__name__ == 'TaskModel_test_tasks_1'
+
+    # Create with custom table name
+    custom_task_model = create_task_model('test_tasks_2', TestBase)
+    assert custom_task_model.__tablename__ == 'test_tasks_2'
+    assert custom_task_model.__name__ == 'TaskModel_test_tasks_2'
+
+
+def test_create_push_notification_config_model():
+    """Test dynamic push notification config model creation."""
+
+    # Create a fresh base to avoid table conflicts
+    class TestBase(DeclarativeBase):
+        pass
+
+    # Create with default table name
+    default_model = create_push_notification_config_model(
+        'test_push_configs_1', TestBase
+    )
+    assert default_model.__tablename__ == 'test_push_configs_1'
+
+    # Create with custom table name
+    custom_model = create_push_notification_config_model(
+        'test_push_configs_2', TestBase
+    )
+    assert custom_model.__tablename__ == 'test_push_configs_2'
+    assert 'test_push_configs_2' in custom_model.__name__
diff --git a/tests/server/test_owner_resolver.py b/tests/server/test_owner_resolver.py
new file mode 100644
index 000000000..e50cc8db4
--- /dev/null
+++ b/tests/server/test_owner_resolver.py
@@ -0,0 +1,30 @@
+from a2a.auth.user import User
+from a2a.server.context import ServerCallContext
+from a2a.server.owner_resolver import resolve_user_scope
+
+
+class SampleUser(User):
+    """A test implementation of the User interface."""
+
+    def __init__(self, user_name: str):
+        self._user_name = user_name
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._user_name
+
+
+def test_resolve_user_scope_with_authenticated_user():
+    """Test resolve_user_scope with an authenticated user in the context."""
+    user = SampleUser(user_name='SampleUser')
+    context = ServerCallContext(user=user)
+    assert resolve_user_scope(context) == 'SampleUser'
+
+
+def test_resolve_user_default_context():
+    """Test resolve_user_scope with default context."""
+    assert resolve_user_scope(ServerCallContext()) == ''
diff --git a/tests/test_types.py b/tests/test_types.py
index 5a01eea0a..afd1ecef6 100644
--- a/tests/test_types.py
+++ b/tests/test_types.py
@@ -1,82 +1,37 @@
-from typing import Any
+"""Tests for protobuf-based A2A types.
 
-import pytest
+This module tests the proto-generated types from a2a_pb2, using protobuf
+patterns like ParseDict, proto constructors, and MessageToDict.
+"""
 
-from pydantic import ValidationError
+from typing import Any
 
-from a2a.types import (
-    A2AError,
-    A2ARequest,
-    AgentAuthentication,
+from a2a.types.a2a_pb2 import (
+    APIKeySecurityScheme,
     AgentCapabilities,
     AgentCard,
     AgentProvider,
     AgentSkill,
     Artifact,
     CancelTaskRequest,
-    CancelTaskResponse,
-    ContentTypeNotSupportedError,
-    DataPart,
-    FileBase,
-    FilePart,
-    FileWithBytes,
-    FileWithUri,
     GetTaskPushNotificationConfigRequest,
-    GetTaskPushNotificationConfigResponse,
     GetTaskRequest,
-    GetTaskResponse,
-    InternalError,
-    InvalidParamsError,
-    InvalidRequestError,
-    JSONParseError,
-    JSONRPCError,
-    JSONRPCErrorResponse,
-    JSONRPCMessage,
-    JSONRPCRequest,
-    JSONRPCResponse,
     Message,
-    MethodNotFoundError,
     Part,
-    PartBase,
-    PushNotificationAuthenticationInfo,
-    PushNotificationConfig,
-    PushNotificationNotSupportedError,
+    Role,
+    SecurityScheme,
     SendMessageRequest,
-    SendMessageResponse,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
-    SetTaskPushNotificationConfigRequest,
-    SetTaskPushNotificationConfigResponse,
+    SubscribeToTaskRequest,
     Task,
-    TaskArtifactUpdateEvent,
-    TaskIdParams,
-    TaskNotCancelableError,
-    TaskNotFoundError,
     TaskPushNotificationConfig,
-    TaskQueryParams,
-    TaskResubscriptionRequest,
-    MessageSendParams,
     TaskState,
     TaskStatus,
-    TaskStatusUpdateEvent,
-    TextPart,
-    UnsupportedOperationError,
-    GetTaskSuccessResponse,
-    SendStreamingMessageSuccessResponse,
-    SendMessageSuccessResponse,
-    CancelTaskSuccessResponse,
-    Role,
-    SetTaskPushNotificationConfigSuccessResponse,
-    GetTaskPushNotificationConfigSuccessResponse,
 )
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.struct_pb2 import Struct, Value
 
-# --- Helper Data ---
 
-MINIMAL_AGENT_AUTH: dict[str, Any] = {'schemes': ['Bearer']}
-FULL_AGENT_AUTH: dict[str, Any] = {
-    'schemes': ['Bearer', 'Basic'],
-    'credentials': 'user:pass',
-}
+# --- Helper Data ---
 
 MINIMAL_AGENT_SKILL: dict[str, Any] = {
     'id': 'skill-123',
@@ -84,6 +39,7 @@
     'description': 'Finds recipes',
     'tags': ['cooking'],
 }
+
 FULL_AGENT_SKILL: dict[str, Any] = {
     'id': 'skill-123',
     'name': 'Recipe Finder',
@@ -95,1317 +51,541 @@
 }
 
 MINIMAL_AGENT_CARD: dict[str, Any] = {
-    'authentication': MINIMAL_AGENT_AUTH,
-    'capabilities': {},  # AgentCapabilities is required but can be empty
+    'capabilities': {},
     'defaultInputModes': ['text/plain'],
     'defaultOutputModes': ['application/json'],
     'description': 'Test Agent',
     'name': 'TestAgent',
     'skills': [MINIMAL_AGENT_SKILL],
-    'url': 'http://example.com/agent',
-    'version': '1.0',
-}
-
-TEXT_PART_DATA: dict[str, Any] = {'type': 'text', 'text': 'Hello'}
-FILE_URI_PART_DATA: dict[str, Any] = {
-    'type': 'file',
-    'file': {'uri': 'file:///path/to/file.txt', 'mimeType': 'text/plain'},
-}
-FILE_BYTES_PART_DATA: dict[str, Any] = {
-    'type': 'file',
-    'file': {'bytes': 'aGVsbG8=', 'name': 'hello.txt'},  # base64 for "hello"
-}
-DATA_PART_DATA: dict[str, Any] = {'type': 'data', 'data': {'key': 'value'}}
-
-MINIMAL_MESSAGE_USER: dict[str, Any] = {
-    'role': 'user',
-    'parts': [TEXT_PART_DATA],
-    'messageId': 'msg-123',
-    'type': 'message',
-}
-
-AGENT_MESSAGE_WITH_FILE: dict[str, Any] = {
-    'role': 'agent',
-    'parts': [TEXT_PART_DATA, FILE_URI_PART_DATA],
-    'metadata': {'timestamp': 'now'},
-    'messageId': 'msg-456',
-}
-
-MINIMAL_TASK_STATUS: dict[str, Any] = {'state': 'submitted'}
-FULL_TASK_STATUS: dict[str, Any] = {
-    'state': 'working',
-    'message': MINIMAL_MESSAGE_USER,
-    'timestamp': '2023-10-27T10:00:00Z',
-}
-
-MINIMAL_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': MINIMAL_TASK_STATUS,
-    'type': 'task',
-}
-FULL_TASK: dict[str, Any] = {
-    'id': 'task-abc',
-    'contextId': 'session-xyz',
-    'status': FULL_TASK_STATUS,
-    'history': [MINIMAL_MESSAGE_USER, AGENT_MESSAGE_WITH_FILE],
-    'artifacts': [
-        {
-            'artifactId': 'artifact-123',
-            'parts': [DATA_PART_DATA],
-            'name': 'result_data',
-        }
+    'supportedInterfaces': [
+        {'url': 'http://example.com/agent', 'protocolBinding': 'HTTP+JSON'}
     ],
-    'metadata': {'priority': 'high'},
-    'type': 'task',
-}
-
-MINIMAL_TASK_ID_PARAMS: dict[str, Any] = {'id': 'task-123'}
-FULL_TASK_ID_PARAMS: dict[str, Any] = {
-    'id': 'task-456',
-    'metadata': {'source': 'test'},
-}
-
-JSONRPC_ERROR_DATA: dict[str, Any] = {
-    'code': -32600,
-    'message': 'Invalid Request',
+    'version': '1.0',
 }
-JSONRPC_SUCCESS_RESULT: dict[str, Any] = {'status': 'ok', 'data': [1, 2, 3]}
-
-# --- Test Functions ---
-
 
-def test_agent_authentication_valid():
-    auth = AgentAuthentication(**MINIMAL_AGENT_AUTH)
-    assert auth.schemes == ['Bearer']
-    assert auth.credentials is None
 
-    auth_full = AgentAuthentication(**FULL_AGENT_AUTH)
-    assert auth_full.schemes == ['Bearer', 'Basic']
-    assert auth_full.credentials == 'user:pass'
-
-
-def test_agent_authentication_invalid():
-    with pytest.raises(ValidationError):
-        AgentAuthentication(
-            credentials='only_creds'
-        )  # Missing schemes  # type: ignore
-
-        AgentAuthentication(
-            schemes=['Bearer'],
-            extra_field='extra',  # type: ignore
-        )  # Extra field
+# --- Test Agent Types ---
 
 
 def test_agent_capabilities():
-    caps = AgentCapabilities(
-        streaming=None, stateTransitionHistory=None, pushNotifications=None
-    )  # All optional
-    assert caps.pushNotifications is None
-    assert caps.stateTransitionHistory is None
-    assert caps.streaming is None
+    """Test AgentCapabilities proto construction."""
+    # Empty capabilities
+    caps = AgentCapabilities()
+    assert caps.streaming is False  # Proto default
+    assert caps.push_notifications is False
 
+    # Full capabilities
     caps_full = AgentCapabilities(
-        pushNotifications=True, stateTransitionHistory=False, streaming=True
+        push_notifications=True,
+        streaming=True,
     )
-    assert caps_full.pushNotifications is True
-    assert caps_full.stateTransitionHistory is False
+    assert caps_full.push_notifications is True
     assert caps_full.streaming is True
 
 
 def test_agent_provider():
-    provider = AgentProvider(organization='Test Org', url='http://test.org')
+    """Test AgentProvider proto construction."""
+    provider = AgentProvider(
+        organization='Test Org',
+        url='http://test.org',
+    )
     assert provider.organization == 'Test Org'
     assert provider.url == 'http://test.org'
 
-    with pytest.raises(ValidationError):
-        AgentProvider(organization='Test Org')  # Missing url  # type: ignore
-
 
-def test_agent_skill_valid():
-    skill = AgentSkill(**MINIMAL_AGENT_SKILL)
+def test_agent_skill():
+    """Test AgentSkill proto construction and ParseDict."""
+    # Direct construction
+    skill = AgentSkill(
+        id='skill-123',
+        name='Recipe Finder',
+        description='Finds recipes',
+        tags=['cooking'],
+    )
     assert skill.id == 'skill-123'
     assert skill.name == 'Recipe Finder'
     assert skill.description == 'Finds recipes'
-    assert skill.tags == ['cooking']
-    assert skill.examples is None
-
-    skill_full = AgentSkill(**FULL_AGENT_SKILL)
-    assert skill_full.examples == ['Find me a pasta recipe']
-    assert skill_full.inputModes == ['text/plain']
-
-
-def test_agent_skill_invalid():
-    with pytest.raises(ValidationError):
-        AgentSkill(
-            id='abc', name='n', description='d'
-        )  # Missing tags  # type: ignore
+    assert list(skill.tags) == ['cooking']
 
-    AgentSkill(
-        **MINIMAL_AGENT_SKILL,
-        invalid_extra='foo',  # type: ignore
-    )  # Extra field
+    # ParseDict from dictionary
+    skill_full = ParseDict(FULL_AGENT_SKILL, AgentSkill())
+    assert skill_full.id == 'skill-123'
+    assert list(skill_full.examples) == ['Find me a pasta recipe']
+    assert list(skill_full.input_modes) == ['text/plain']
 
 
-def test_agent_card_valid():
-    card = AgentCard(**MINIMAL_AGENT_CARD)
+def test_agent_card():
+    """Test AgentCard proto construction and ParseDict."""
+    card = ParseDict(MINIMAL_AGENT_CARD, AgentCard())
     assert card.name == 'TestAgent'
     assert card.version == '1.0'
-    assert card.authentication.schemes == ['Bearer']
     assert len(card.skills) == 1
     assert card.skills[0].id == 'skill-123'
-    assert card.provider is None  # Optional
+    assert not card.HasField('provider')  # Optional, not set
 
 
-def test_agent_card_invalid():
-    bad_card_data = MINIMAL_AGENT_CARD.copy()
-    del bad_card_data['name']
-    with pytest.raises(ValidationError):
-        AgentCard(**bad_card_data)  # Missing name
+def test_security_scheme():
+    """Test SecurityScheme oneof handling."""
+    # API Key scheme
+    api_key = APIKeySecurityScheme(
+        name='X-API-KEY',
+        location='header',  # location is a string in proto
+    )
+    scheme = SecurityScheme(api_key_security_scheme=api_key)
+    assert scheme.HasField('api_key_security_scheme')
+    assert scheme.api_key_security_scheme.name == 'X-API-KEY'
+    assert scheme.api_key_security_scheme.location == 'header'
 
 
-# --- Test Parts ---
+# --- Test Part Types ---
 
 
 def test_text_part():
-    part = TextPart(**TEXT_PART_DATA)
-    assert part.type == 'text'
+    """Test Part with text field (Part has text as a direct string field)."""
+    # Part with text
+    part = Part(text='Hello')
     assert part.text == 'Hello'
-    assert part.metadata is None
-
-    with pytest.raises(ValidationError):
-        TextPart(type='text')  # Missing text # type: ignore
-    with pytest.raises(ValidationError):
-        TextPart(
-            type='file',  # type: ignore
-            text='hello',
-        )  # Wrong type literal
+    # Check oneof
+    assert part.WhichOneof('content') == 'text'
 
 
-def test_file_part_variants():
-    # URI variant
-    file_uri = FileWithUri(
-        uri='file:///path/to/file.txt', mimeType='text/plain'
+def test_part_with_url():
+    """Test Part with url."""
+    part = Part(
+        url='file:///path/to/file.txt',
+        media_type='text/plain',
     )
-    part_uri = FilePart(type='file', file=file_uri)
-    assert isinstance(part_uri.file, FileWithUri)
-    assert part_uri.file.uri == 'file:///path/to/file.txt'
-    assert part_uri.file.mimeType == 'text/plain'
-    assert not hasattr(part_uri.file, 'bytes')
-
-    # Bytes variant
-    file_bytes = FileWithBytes(bytes='aGVsbG8=', name='hello.txt')
-    part_bytes = FilePart(type='file', file=file_bytes)
-    assert isinstance(part_bytes.file, FileWithBytes)
-    assert part_bytes.file.bytes == 'aGVsbG8='
-    assert part_bytes.file.name == 'hello.txt'
-    assert not hasattr(part_bytes.file, 'uri')
-
-    # Test deserialization directly
-    part_uri_deserialized = FilePart.model_validate(FILE_URI_PART_DATA)
-    assert isinstance(part_uri_deserialized.file, FileWithUri)
-    assert part_uri_deserialized.file.uri == 'file:///path/to/file.txt'
-
-    part_bytes_deserialized = FilePart.model_validate(FILE_BYTES_PART_DATA)
-    assert isinstance(part_bytes_deserialized.file, FileWithBytes)
-    assert part_bytes_deserialized.file.bytes == 'aGVsbG8='
-
-    # Invalid - wrong type literal
-    with pytest.raises(ValidationError):
-        FilePart(type='text', file=file_uri)  # type: ignore
-
-    FilePart(**FILE_URI_PART_DATA, extra='extra')  # type: ignore
-
-
-def test_data_part():
-    part = DataPart(**DATA_PART_DATA)
-    assert part.type == 'data'
-    assert part.data == {'key': 'value'}
-
-    with pytest.raises(ValidationError):
-        DataPart(type='data')  # Missing data  # type: ignore
+    assert part.url == 'file:///path/to/file.txt'
+    assert part.media_type == 'text/plain'
 
 
-def test_part_root_model():
-    # Test deserialization of the Union RootModel
-    part_text = Part.model_validate(TEXT_PART_DATA)
-    assert isinstance(part_text.root, TextPart)
-    assert part_text.root.text == 'Hello'
-
-    part_file = Part.model_validate(FILE_URI_PART_DATA)
-    assert isinstance(part_file.root, FilePart)
-    assert isinstance(part_file.root.file, FileWithUri)
+def test_part_with_raw():
+    """Test Part with raw bytes."""
+    part = Part(
+        raw=b'hello',
+        filename='hello.txt',
+    )
+    assert part.raw == b'hello'
+    assert part.filename == 'hello.txt'
 
-    part_data = Part.model_validate(DATA_PART_DATA)
-    assert isinstance(part_data.root, DataPart)
-    assert part_data.root.data == {'key': 'value'}
 
-    # Test serialization
-    assert part_text.model_dump(exclude_none=True) == TEXT_PART_DATA
-    assert part_file.model_dump(exclude_none=True) == FILE_URI_PART_DATA
-    assert part_data.model_dump(exclude_none=True) == DATA_PART_DATA
+def test_part_with_data():
+    """Test Part with data."""
+    s = Struct()
+    s.update({'key': 'value'})
+    part = Part(data=Value(struct_value=s))
+    assert part.HasField('data')
 
 
 # --- Test Message and Task ---
 
 
 def test_message():
-    msg = Message(**MINIMAL_MESSAGE_USER)
-    assert msg.role == Role.user
-    assert len(msg.parts) == 1
-    assert isinstance(
-        msg.parts[0].root, TextPart
-    )  # Access root for RootModel Part
-    assert msg.metadata is None
-
-    msg_agent = Message(**AGENT_MESSAGE_WITH_FILE)
-    assert msg_agent.role == Role.agent
-    assert len(msg_agent.parts) == 2
-    assert isinstance(msg_agent.parts[1].root, FilePart)
-    assert msg_agent.metadata == {'timestamp': 'now'}
-
-    with pytest.raises(ValidationError):
-        Message(
-            role='invalid_role',  # type: ignore
-            parts=[TEXT_PART_DATA],  # type: ignore
-        )  # Invalid enum
-    with pytest.raises(ValidationError):
-        Message(role=Role.user)  # Missing parts  # type: ignore
-
-
-def test_task_status():
-    status = TaskStatus(**MINIMAL_TASK_STATUS)
-    assert status.state == TaskState.submitted
-    assert status.message is None
-    assert status.timestamp is None
-
-    status_full = TaskStatus(**FULL_TASK_STATUS)
-    assert status_full.state == TaskState.working
-    assert isinstance(status_full.message, Message)
-    assert status_full.timestamp == '2023-10-27T10:00:00Z'
-
-    with pytest.raises(ValidationError):
-        TaskStatus(state='invalid_state')  # Invalid enum  # type: ignore
+    """Test Message proto construction."""
+    part = Part(text='Hello')
 
+    msg = Message(
+        role=Role.ROLE_USER,
+        message_id='msg-123',
+    )
+    msg.parts.append(part)
 
-def test_task():
-    task = Task(**MINIMAL_TASK)
-    assert task.id == 'task-abc'
-    assert task.contextId == 'session-xyz'
-    assert task.status.state == TaskState.submitted
-    assert task.history is None
-    assert task.artifacts is None
-    assert task.metadata is None
+    assert msg.role == Role.ROLE_USER
+    assert msg.message_id == 'msg-123'
+    assert len(msg.parts) == 1
+    assert msg.parts[0].text == 'Hello'
 
-    task_full = Task(**FULL_TASK)
-    assert task_full.id == 'task-abc'
-    assert task_full.status.state == TaskState.working
-    assert task_full.history is not None and len(task_full.history) == 2
-    assert isinstance(task_full.history[0], Message)
-    assert task_full.artifacts is not None and len(task_full.artifacts) == 1
-    assert isinstance(task_full.artifacts[0], Artifact)
-    assert task_full.artifacts[0].name == 'result_data'
-    assert task_full.metadata == {'priority': 'high'}
 
-    with pytest.raises(ValidationError):
-        Task(id='abc', sessionId='xyz')  # Missing status # type: ignore
+def test_message_with_metadata():
+    """Test Message with metadata."""
+    msg = Message(
+        role=Role.ROLE_AGENT,
+        message_id='msg-456',
+    )
+    msg.metadata.update({'timestamp': 'now'})
 
+    assert msg.role == Role.ROLE_AGENT
+    assert dict(msg.metadata) == {'timestamp': 'now'}
 
-# --- Test JSON-RPC Structures ---
 
+def test_task_status():
+    """Test TaskStatus proto construction."""
+    status = TaskStatus(state=TaskState.TASK_STATE_SUBMITTED)
+    assert status.state == TaskState.TASK_STATE_SUBMITTED
+    assert not status.HasField('message')
+    # timestamp is a Timestamp proto, default has seconds=0
+    assert status.timestamp.seconds == 0
 
-def test_jsonrpc_error():
-    err = JSONRPCError(code=-32600, message='Invalid Request')
-    assert err.code == -32600
-    assert err.message == 'Invalid Request'
-    assert err.data is None
+    # TaskStatus with timestamp
+    from google.protobuf.timestamp_pb2 import Timestamp
 
-    err_data = JSONRPCError(
-        code=-32001, message='Task not found', data={'taskId': '123'}
+    ts = Timestamp()
+    ts.FromJsonString('2023-10-27T10:00:00Z')
+    status_working = TaskStatus(
+        state=TaskState.TASK_STATE_WORKING,
+        timestamp=ts,
     )
-    assert err_data.code == -32001
-    assert err_data.data == {'taskId': '123'}
+    assert status_working.state == TaskState.TASK_STATE_WORKING
+    assert status_working.timestamp.seconds == ts.seconds
 
 
-def test_jsonrpc_request():
-    req = JSONRPCRequest(jsonrpc='2.0', method='test_method', id=1)
-    assert req.jsonrpc == '2.0'
-    assert req.method == 'test_method'
-    assert req.id == 1
-    assert req.params is None
-
-    req_params = JSONRPCRequest(
-        jsonrpc='2.0', method='add', params={'a': 1, 'b': 2}, id='req-1'
+def test_task():
+    """Test Task proto construction."""
+    status = TaskStatus(state=TaskState.TASK_STATE_SUBMITTED)
+    task = Task(
+        id='task-abc',
+        context_id='session-xyz',
+        status=status,
     )
-    assert req_params.params == {'a': 1, 'b': 2}
-    assert req_params.id == 'req-1'
-
-    with pytest.raises(ValidationError):
-        JSONRPCRequest(
-            jsonrpc='1.0',  # type: ignore
-            method='m',
-            id=1,
-        )  # Wrong version
-    with pytest.raises(ValidationError):
-        JSONRPCRequest(jsonrpc='2.0', id=1)  # Missing method  # type: ignore
-
-
-def test_jsonrpc_error_response():
-    err_obj = JSONRPCError(**JSONRPC_ERROR_DATA)
-    resp = JSONRPCErrorResponse(jsonrpc='2.0', error=err_obj, id='err-1')
-    assert resp.jsonrpc == '2.0'
-    assert resp.id == 'err-1'
-    assert resp.error.code == -32600
-    assert resp.error.message == 'Invalid Request'
-
-    with pytest.raises(ValidationError):
-        JSONRPCErrorResponse(
-            jsonrpc='2.0', id='err-1'
-        )  # Missing error # type: ignore
-
-
-def test_jsonrpc_response_root_model() -> None:
-    # Success case
-    success_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': MINIMAL_TASK,
-        'id': 1,
-    }
-    resp_success = JSONRPCResponse.model_validate(success_data)
-    assert isinstance(resp_success.root, SendMessageSuccessResponse)
-    assert resp_success.root.result == Task(**MINIMAL_TASK)
-
-    # Error case
-    error_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPC_ERROR_DATA,
-        'id': 'err-1',
-    }
-    resp_error = JSONRPCResponse.model_validate(error_data)
-    assert isinstance(resp_error.root, JSONRPCErrorResponse)
-    assert resp_error.root.error.code == -32600
-    # Note: .model_dump() might serialize the nested error model
-    assert resp_error.model_dump(exclude_none=True) == error_data
 
-    # Invalid case (neither success nor error structure)
-    with pytest.raises(ValidationError):
-        JSONRPCResponse.model_validate({'jsonrpc': '2.0', 'id': 1})
+    assert task.id == 'task-abc'
+    assert task.context_id == 'session-xyz'
+    assert task.status.state == TaskState.TASK_STATE_SUBMITTED
+    assert len(task.history) == 0
+    assert len(task.artifacts) == 0
 
 
-# --- Test Request/Response Wrappers ---
+def test_task_with_history():
+    """Test Task with history."""
+    status = TaskStatus(state=TaskState.TASK_STATE_WORKING)
+    task = Task(
+        id='task-abc',
+        context_id='session-xyz',
+        status=status,
+    )
 
+    # Add message to history
+    msg = Message(role=Role.ROLE_USER, message_id='msg-1')
+    msg.parts.append(Part(text='Hello'))
+    task.history.append(msg)
 
-def test_send_message_request() -> None:
-    params = MessageSendParams(message=Message(**MINIMAL_MESSAGE_USER))
-    req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'message/send',
-        'params': params.model_dump(),
-        'id': 5,
-    }
-    req = SendMessageRequest.model_validate(req_data)
-    assert req.method == 'message/send'
-    assert isinstance(req.params, MessageSendParams)
-    assert req.params.message.role == Role.user
-
-    with pytest.raises(ValidationError):  # Wrong method literal
-        SendMessageRequest.model_validate(
-            {**req_data, 'method': 'wrong/method'}
-        )
-
-
-def test_send_subscribe_request() -> None:
-    params = MessageSendParams(message=Message(**MINIMAL_MESSAGE_USER))
-    req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'message/stream',
-        'params': params.model_dump(),
-        'id': 5,
-    }
-    req = SendStreamingMessageRequest.model_validate(req_data)
-    assert req.method == 'message/stream'
-    assert isinstance(req.params, MessageSendParams)
-    assert req.params.message.role == Role.user
-
-    with pytest.raises(ValidationError):  # Wrong method literal
-        SendStreamingMessageRequest.model_validate(
-            {**req_data, 'method': 'wrong/method'}
-        )
-
-
-def test_get_task_request() -> None:
-    params = TaskQueryParams(id='task-1', historyLength=2)
-    req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/get',
-        'params': params.model_dump(),
-        'id': 5,
-    }
-    req = GetTaskRequest.model_validate(req_data)
-    assert req.method == 'tasks/get'
-    assert isinstance(req.params, TaskQueryParams)
-    assert req.params.id == 'task-1'
-    assert req.params.historyLength == 2
-
-    with pytest.raises(ValidationError):  # Wrong method literal
-        GetTaskRequest.model_validate({**req_data, 'method': 'wrong/method'})
-
-
-def test_cancel_task_request() -> None:
-    params = TaskIdParams(id='task-1')
-    req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/cancel',
-        'params': params.model_dump(),
-        'id': 5,
-    }
-    req = CancelTaskRequest.model_validate(req_data)
-    assert req.method == 'tasks/cancel'
-    assert isinstance(req.params, TaskIdParams)
-    assert req.params.id == 'task-1'
-
-    with pytest.raises(ValidationError):  # Wrong method literal
-        CancelTaskRequest.model_validate({**req_data, 'method': 'wrong/method'})
+    assert len(task.history) == 1
+    assert task.history[0].role == Role.ROLE_USER
 
 
-def test_get_task_response() -> None:
-    resp_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': MINIMAL_TASK,
-        'id': 'resp-1',
-    }
-    resp = GetTaskResponse.model_validate(resp_data)
-    assert resp.root.id == 'resp-1'
-    assert isinstance(resp.root, GetTaskSuccessResponse)
-    assert isinstance(resp.root.result, Task)
-    assert resp.root.result.id == 'task-abc'
-
-    with pytest.raises(ValidationError):  # Result is not a Task
-        GetTaskResponse.model_validate(
-            {'jsonrpc': '2.0', 'result': {'wrong': 'data'}, 'id': 1}
-        )
-
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = GetTaskResponse.model_validate(resp_data_err)
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
-
-
-def test_send_message_response() -> None:
-    resp_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': MINIMAL_TASK,
-        'id': 'resp-1',
-    }
-    resp = SendMessageResponse.model_validate(resp_data)
-    assert resp.root.id == 'resp-1'
-    assert isinstance(resp.root, SendMessageSuccessResponse)
-    assert isinstance(resp.root.result, Task)
-    assert resp.root.result.id == 'task-abc'
-
-    with pytest.raises(ValidationError):  # Result is not a Task
-        SendMessageResponse.model_validate(
-            {'jsonrpc': '2.0', 'result': {'wrong': 'data'}, 'id': 1}
-        )
-
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = SendMessageResponse.model_validate(resp_data_err)
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
-
-
-def test_cancel_task_response() -> None:
-    resp_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': MINIMAL_TASK,
-        'id': 1,
-    }
-    resp = CancelTaskResponse.model_validate(resp_data)
-    assert resp.root.id == 1
-    assert isinstance(resp.root, CancelTaskSuccessResponse)
-    assert isinstance(resp.root.result, Task)
-    assert resp.root.result.id == 'task-abc'
-
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = CancelTaskResponse.model_validate(resp_data_err)
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
-
-
-def test_send_message_streaming_status_update_response() -> None:
-    task_status_update_event_data: dict[str, Any] = {
-        'status': MINIMAL_TASK_STATUS,
-        'taskId': '1',
-        'contextId': '2',
-        'final': False,
-        'type': 'status-update',
-    }
-
-    event_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'id': 1,
-        'result': task_status_update_event_data,
-    }
-    response = SendStreamingMessageResponse.model_validate(event_data)
-    assert response.root.id == 1
-    assert isinstance(response.root, SendStreamingMessageSuccessResponse)
-    assert isinstance(response.root.result, TaskStatusUpdateEvent)
-    assert response.root.result.status.state == TaskState.submitted
-    assert response.root.result.taskId == '1'
-    assert not response.root.result.final
-
-    with pytest.raises(
-        ValidationError
-    ):  # Result is not a TaskStatusUpdateEvent
-        SendStreamingMessageResponse.model_validate(
-            {'jsonrpc': '2.0', 'result': {'wrong': 'data'}, 'id': 1}
-        )
-
-    event_data = {
-        'jsonrpc': '2.0',
-        'id': 1,
-        'result': {**task_status_update_event_data, 'final': True},
-    }
-    response = SendStreamingMessageResponse.model_validate(event_data)
-    assert response.root.id == 1
-    assert isinstance(response.root, SendStreamingMessageSuccessResponse)
-    assert isinstance(response.root.result, TaskStatusUpdateEvent)
-    assert response.root.result.final
-
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = SendStreamingMessageResponse.model_validate(resp_data_err)
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
-
-
-def test_send_message_streaming_artifact_update_response() -> None:
-    text_part = TextPart(**TEXT_PART_DATA)
-    data_part = DataPart(**DATA_PART_DATA)
-    artifact = Artifact(
-        artifactId='artifact-123',
-        name='result_data',
-        parts=[Part(root=text_part), Part(root=data_part)],
-    )
-    task_artifact_update_event_data: dict[str, Any] = {
-        'artifact': artifact,
-        'taskId': 'task_id',
-        'contextId': '2',
-        'append': False,
-        'lastChunk': True,
-        'type': 'artifact-update',
-    }
-    event_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'id': 1,
-        'result': task_artifact_update_event_data,
-    }
-    response = SendStreamingMessageResponse.model_validate(event_data)
-    assert response.root.id == 1
-    assert isinstance(response.root, SendStreamingMessageSuccessResponse)
-    assert isinstance(response.root.result, TaskArtifactUpdateEvent)
-    assert response.root.result.artifact.artifactId == 'artifact-123'
-    assert response.root.result.artifact.name == 'result_data'
-    assert response.root.result.taskId == 'task_id'
-    assert not response.root.result.append
-    assert response.root.result.lastChunk
-    assert len(response.root.result.artifact.parts) == 2
-    assert isinstance(response.root.result.artifact.parts[0].root, TextPart)
-    assert isinstance(response.root.result.artifact.parts[1].root, DataPart)
-
-
-def test_set_task_push_notification_response() -> None:
-    task_push_config = TaskPushNotificationConfig(
-        taskId='t2',
-        pushNotificationConfig=PushNotificationConfig(
-            url='https://example.com', token='token'
-        ),
-    )
-    resp_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': task_push_config.model_dump(),
-        'id': 1,
-    }
-    resp = SetTaskPushNotificationConfigResponse.model_validate(resp_data)
-    assert resp.root.id == 1
-    assert isinstance(resp.root, SetTaskPushNotificationConfigSuccessResponse)
-    assert isinstance(resp.root.result, TaskPushNotificationConfig)
-    assert resp.root.result.taskId == 't2'
-    assert resp.root.result.pushNotificationConfig.url == 'https://example.com'
-    assert resp.root.result.pushNotificationConfig.token == 'token'
-    assert resp.root.result.pushNotificationConfig.authentication is None
-
-    auth_info_dict: dict[str, Any] = {
-        'schemes': ['Bearer', 'Basic'],
-        'credentials': 'user:pass',
-    }
-    task_push_config.pushNotificationConfig.authentication = (
-        PushNotificationAuthenticationInfo(**auth_info_dict)
-    )
-    resp_data = {
-        'jsonrpc': '2.0',
-        'result': task_push_config.model_dump(),
-        'id': 1,
-    }
-    resp = SetTaskPushNotificationConfigResponse.model_validate(resp_data)
-    assert isinstance(resp.root, SetTaskPushNotificationConfigSuccessResponse)
-    assert resp.root.result.pushNotificationConfig.authentication is not None
-    assert resp.root.result.pushNotificationConfig.authentication.schemes == [
-        'Bearer',
-        'Basic',
-    ]
-    assert (
-        resp.root.result.pushNotificationConfig.authentication.credentials
-        == 'user:pass'
+def test_task_with_artifacts():
+    """Test Task with artifacts."""
+    status = TaskStatus(state=TaskState.TASK_STATE_COMPLETED)
+    task = Task(
+        id='task-abc',
+        context_id='session-xyz',
+        status=status,
     )
 
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = SetTaskPushNotificationConfigResponse.model_validate(
-        resp_data_err
-    )
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
-
-
-def test_get_task_push_notification_response() -> None:
-    task_push_config = TaskPushNotificationConfig(
-        taskId='t2',
-        pushNotificationConfig=PushNotificationConfig(
-            url='https://example.com', token='token'
-        ),
-    )
-    resp_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'result': task_push_config.model_dump(),
-        'id': 1,
-    }
-    resp = GetTaskPushNotificationConfigResponse.model_validate(resp_data)
-    assert resp.root.id == 1
-    assert isinstance(resp.root, GetTaskPushNotificationConfigSuccessResponse)
-    assert isinstance(resp.root.result, TaskPushNotificationConfig)
-    assert resp.root.result.taskId == 't2'
-    assert resp.root.result.pushNotificationConfig.url == 'https://example.com'
-    assert resp.root.result.pushNotificationConfig.token == 'token'
-    assert resp.root.result.pushNotificationConfig.authentication is None
-
-    auth_info_dict: dict[str, Any] = {
-        'schemes': ['Bearer', 'Basic'],
-        'credentials': 'user:pass',
-    }
-    task_push_config.pushNotificationConfig.authentication = (
-        PushNotificationAuthenticationInfo(**auth_info_dict)
-    )
-    resp_data = {
-        'jsonrpc': '2.0',
-        'result': task_push_config.model_dump(),
-        'id': 1,
-    }
-    resp = GetTaskPushNotificationConfigResponse.model_validate(resp_data)
-    assert isinstance(resp.root, GetTaskPushNotificationConfigSuccessResponse)
-    assert resp.root.result.pushNotificationConfig.authentication is not None
-    assert resp.root.result.pushNotificationConfig.authentication.schemes == [
-        'Bearer',
-        'Basic',
-    ]
-    assert (
-        resp.root.result.pushNotificationConfig.authentication.credentials
-        == 'user:pass'
-    )
+    # Add artifact
+    artifact = Artifact(artifact_id='artifact-123', name='result')
+    s = Struct()
+    s.update({'result': 42})
+    v = Value(struct_value=s)
+    artifact.parts.append(Part(data=v))
+    task.artifacts.append(artifact)
 
-    resp_data_err: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'error': JSONRPCError(**TaskNotFoundError().model_dump()),
-        'id': 'resp-1',
-    }
-    resp_err = GetTaskPushNotificationConfigResponse.model_validate(
-        resp_data_err
-    )
-    assert resp_err.root.id == 'resp-1'
-    assert isinstance(resp_err.root, JSONRPCErrorResponse)
-    assert resp_err.root.error is not None
-    assert isinstance(resp_err.root.error, JSONRPCError)
+    assert len(task.artifacts) == 1
+    assert task.artifacts[0].artifact_id == 'artifact-123'
+    assert task.artifacts[0].name == 'result'
 
 
-# --- Test A2ARequest Root Model ---
+# --- Test Request Types ---
 
 
-def test_a2a_request_root_model() -> None:
-    # SendMessageRequest case
-    send_params = MessageSendParams(message=Message(**MINIMAL_MESSAGE_USER))
-    send_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'message/send',
-        'params': send_params.model_dump(),
-        'id': 1,
-    }
-    a2a_req_send = A2ARequest.model_validate(send_req_data)
-    assert isinstance(a2a_req_send.root, SendMessageRequest)
-    assert a2a_req_send.root.method == 'message/send'
-
-    # SendStreamingMessageRequest case
-    send_subs_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'message/stream',
-        'params': send_params.model_dump(),
-        'id': 1,
-    }
-    a2a_req_send_subs = A2ARequest.model_validate(send_subs_req_data)
-    assert isinstance(a2a_req_send_subs.root, SendStreamingMessageRequest)
-    assert a2a_req_send_subs.root.method == 'message/stream'
-
-    # GetTaskRequest case
-    get_params = TaskQueryParams(id='t2')
-    get_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/get',
-        'params': get_params.model_dump(),
-        'id': 2,
-    }
-    a2a_req_get = A2ARequest.model_validate(get_req_data)
-    assert isinstance(a2a_req_get.root, GetTaskRequest)
-    assert a2a_req_get.root.method == 'tasks/get'
-
-    # CancelTaskRequest case
-    id_params = TaskIdParams(id='t2')
-    cancel_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/cancel',
-        'params': id_params.model_dump(),
-        'id': 2,
-    }
-    a2a_req_cancel = A2ARequest.model_validate(cancel_req_data)
-    assert isinstance(a2a_req_cancel.root, CancelTaskRequest)
-    assert a2a_req_cancel.root.method == 'tasks/cancel'
-
-    # SetTaskPushNotificationConfigRequest
-    task_push_config = TaskPushNotificationConfig(
-        taskId='t2',
-        pushNotificationConfig=PushNotificationConfig(
-            url='https://example.com', token='token'
-        ),
-    )
-    set_push_notif_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/pushNotificationConfig/set',
-        'params': task_push_config.model_dump(),
-        'taskId': 2,
-    }
-    a2a_req_set_push_req = A2ARequest.model_validate(set_push_notif_req_data)
-    assert isinstance(
-        a2a_req_set_push_req.root, SetTaskPushNotificationConfigRequest
-    )
-    assert isinstance(
-        a2a_req_set_push_req.root.params, TaskPushNotificationConfig
-    )
-    assert (
-        a2a_req_set_push_req.root.method == 'tasks/pushNotificationConfig/set'
-    )
+def test_send_message_request():
+    """Test SendMessageRequest proto construction."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-123')
+    msg.parts.append(Part(text='Hello'))
 
-    # GetTaskPushNotificationConfigRequest
-    id_params = TaskIdParams(id='t2')
-    get_push_notif_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/pushNotificationConfig/get',
-        'params': id_params.model_dump(),
-        'taskId': 2,
-    }
-    a2a_req_get_push_req = A2ARequest.model_validate(get_push_notif_req_data)
-    assert isinstance(
-        a2a_req_get_push_req.root, GetTaskPushNotificationConfigRequest
-    )
-    assert isinstance(a2a_req_get_push_req.root.params, TaskIdParams)
-    assert (
-        a2a_req_get_push_req.root.method == 'tasks/pushNotificationConfig/get'
-    )
+    request = SendMessageRequest(message=msg)
+    assert request.message.role == Role.ROLE_USER
+    assert request.message.parts[0].text == 'Hello'
 
-    # TaskResubscriptionRequest
-    task_resubscribe_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'tasks/resubscribe',
-        'params': id_params.model_dump(),
-        'id': 2,
-    }
-    a2a_req_task_resubscribe_req = A2ARequest.model_validate(
-        task_resubscribe_req_data
-    )
-    assert isinstance(
-        a2a_req_task_resubscribe_req.root, TaskResubscriptionRequest
-    )
-    assert isinstance(a2a_req_task_resubscribe_req.root.params, TaskIdParams)
-    assert a2a_req_task_resubscribe_req.root.method == 'tasks/resubscribe'
-
-    # Invalid method case
-    invalid_req_data: dict[str, Any] = {
-        'jsonrpc': '2.0',
-        'method': 'invalid/method',
-        'params': {},
-        'id': 3,
-    }
-    with pytest.raises(ValidationError):
-        A2ARequest.model_validate(invalid_req_data)
 
+def test_get_task_request():
+    """Test GetTaskRequest proto construction."""
+    request = GetTaskRequest(id='task-123')
+    assert request.id == 'task-123'
 
-def test_content_type_not_supported_error():
-    # Test ContentTypeNotSupportedError
-    err = ContentTypeNotSupportedError(
-        code=-32005, message='Incompatible content types'
-    )
-    assert err.code == -32005
-    assert err.message == 'Incompatible content types'
-    assert err.data is None
-
-    with pytest.raises(ValidationError):  # Wrong code
-        ContentTypeNotSupportedError(
-            code=-32000,  # type: ignore
-            message='Incompatible content types',
-        )
-
-    ContentTypeNotSupportedError(
-        code=-32005,
-        message='Incompatible content types',
-        extra='extra',  # type: ignore
-    )
 
+def test_cancel_task_request():
+    """Test CancelTaskRequest proto construction."""
+    request = CancelTaskRequest(id='task-123')
+    assert request.id == 'task-123'
 
-def test_task_not_found_error():
-    # Test TaskNotFoundError
-    err2 = TaskNotFoundError(
-        code=-32001, message='Task not found', data={'taskId': 'abc'}
-    )
-    assert err2.code == -32001
-    assert err2.message == 'Task not found'
-    assert err2.data == {'taskId': 'abc'}
-
-    with pytest.raises(ValidationError):  # Wrong code
-        TaskNotFoundError(code=-32000, message='Task not found')  # type: ignore
-
-    TaskNotFoundError(code=-32001, message='Task not found', extra='extra')  # type: ignore
-
-
-def test_push_notification_not_supported_error():
-    # Test PushNotificationNotSupportedError
-    err3 = PushNotificationNotSupportedError(data={'taskId': 'abc'})
-    assert err3.code == -32003
-    assert err3.message == 'Push Notification is not supported'
-    assert err3.data == {'taskId': 'abc'}
-
-    with pytest.raises(ValidationError):  # Wrong code
-        PushNotificationNotSupportedError(
-            code=-32000,  # type: ignore
-            message='Push Notification is not available',
-        )
-    with pytest.raises(ValidationError):  # Extra field
-        PushNotificationNotSupportedError(
-            code=-32001,
-            message='Push Notification is not available',
-            extra='extra',  # type: ignore
-        )
-
-
-def test_internal_error():
-    # Test InternalError
-    err_internal = InternalError()
-    assert err_internal.code == -32603
-    assert err_internal.message == 'Internal error'
-    assert err_internal.data is None
-
-    err_internal_data = InternalError(
-        code=-32603, message='Internal error', data={'details': 'stack trace'}
-    )
-    assert err_internal_data.data == {'details': 'stack trace'}
 
-    with pytest.raises(ValidationError):  # Wrong code
-        InternalError(code=-32000, message='Internal error')  # type: ignore
+def test_subscribe_to_task_request():
+    """Test SubscribeToTaskRequest proto construction."""
+    request = SubscribeToTaskRequest(id='task-123')
+    assert request.id == 'task-123'
 
-    InternalError(code=-32603, message='Internal error', extra='extra')  # type: ignore
 
+def test_set_task_push_notification_config_request():
+    """Test CreateTaskPushNotificationConfigRequest proto construction."""
+    request = TaskPushNotificationConfig(
+        task_id='task-123',
+        url='https://example.com/webhook',
+    )
+    assert request.task_id == 'task-123'
+    assert request.url == 'https://example.com/webhook'
 
-def test_invalid_params_error():
-    # Test InvalidParamsError
-    err_params = InvalidParamsError()
-    assert err_params.code == -32602
-    assert err_params.message == 'Invalid parameters'
-    assert err_params.data is None
 
-    err_params_data = InvalidParamsError(
-        code=-32602, message='Invalid parameters', data=['param1', 'param2']
+def test_get_task_push_notification_config_request():
+    """Test GetTaskPushNotificationConfigRequest proto construction."""
+    request = GetTaskPushNotificationConfigRequest(
+        task_id='task-123', id='config-1'
     )
-    assert err_params_data.data == ['param1', 'param2']
+    assert request.task_id == 'task-123'
 
-    with pytest.raises(ValidationError):  # Wrong code
-        InvalidParamsError(code=-32000, message='Invalid parameters')  # type: ignore
 
-    InvalidParamsError(
-        code=-32602,
-        message='Invalid parameters',
-        extra='extra',  # type: ignore
-    )
+# --- Test Enum Values ---
 
 
-def test_invalid_request_error():
-    # Test InvalidRequestError
-    err_request = InvalidRequestError()
-    assert err_request.code == -32600
-    assert err_request.message == 'Request payload validation error'
-    assert err_request.data is None
+def test_role_enum():
+    """Test Role enum values."""
+    assert Role.ROLE_UNSPECIFIED == 0
+    assert Role.ROLE_USER == 1
+    assert Role.ROLE_AGENT == 2
 
-    err_request_data = InvalidRequestError(data={'field': 'missing'})
-    assert err_request_data.data == {'field': 'missing'}
 
-    with pytest.raises(ValidationError):  # Wrong code
-        InvalidRequestError(
-            code=-32000,  # type: ignore
-            message='Request payload validation error',
-        )
+def test_task_state_enum():
+    """Test TaskState enum values."""
+    assert TaskState.TASK_STATE_UNSPECIFIED == 0
+    assert TaskState.TASK_STATE_SUBMITTED == 1
+    assert TaskState.TASK_STATE_WORKING == 2
+    assert TaskState.TASK_STATE_COMPLETED == 3
+    assert TaskState.TASK_STATE_FAILED == 4
+    assert TaskState.TASK_STATE_CANCELED == 5
+    assert TaskState.TASK_STATE_INPUT_REQUIRED == 6
+    assert TaskState.TASK_STATE_REJECTED == 7
+    assert TaskState.TASK_STATE_AUTH_REQUIRED == 8
 
-    InvalidRequestError(
-        code=-32600,
-        message='Request payload validation error',
-        extra='extra',  # type: ignore
-    )  # type: ignore
 
+# --- Test ParseDict and MessageToDict ---
 
-def test_json_parse_error():
-    # Test JSONParseError
-    err_parse = JSONParseError(code=-32700, message='Invalid JSON payload')
-    assert err_parse.code == -32700
-    assert err_parse.message == 'Invalid JSON payload'
-    assert err_parse.data is None
 
-    err_parse_data = JSONParseError(data={'foo': 'bar'})  # Explicit None data
-    assert err_parse_data.data == {'foo': 'bar'}
+def test_parse_dict_agent_card():
+    """Test ParseDict for AgentCard."""
+    card = ParseDict(MINIMAL_AGENT_CARD, AgentCard())
+    assert card.name == 'TestAgent'
+    assert card.supported_interfaces[0].url == 'http://example.com/agent'
 
-    with pytest.raises(ValidationError):  # Wrong code
-        JSONParseError(code=-32000, message='Invalid JSON payload')  # type: ignore
+    # Round-trip through MessageToDict
+    card_dict = MessageToDict(card)
+    assert card_dict['name'] == 'TestAgent'
+    assert (
+        card_dict['supportedInterfaces'][0]['url'] == 'http://example.com/agent'
+    )
 
-    JSONParseError(code=-32700, message='Invalid JSON payload', extra='extra')  # type: ignore
 
+def test_parse_dict_task():
+    """Test ParseDict for Task with nested structures."""
+    task_data = {
+        'id': 'task-123',
+        'contextId': 'ctx-456',
+        'status': {
+            'state': 'TASK_STATE_WORKING',
+        },
+        'history': [
+            {
+                'role': 'ROLE_USER',
+                'messageId': 'msg-1',
+                'parts': [{'text': 'Hello'}],
+            }
+        ],
+    }
+    task = ParseDict(task_data, Task())
+    assert task.id == 'task-123'
+    assert task.context_id == 'ctx-456'
+    assert task.status.state == TaskState.TASK_STATE_WORKING
+    assert len(task.history) == 1
+    assert task.history[0].role == Role.ROLE_USER
 
-def test_method_not_found_error():
-    # Test MethodNotFoundError
-    err_parse = MethodNotFoundError()
-    assert err_parse.code == -32601
-    assert err_parse.message == 'Method not found'
-    assert err_parse.data is None
 
-    err_parse_data = JSONParseError(data={'foo': 'bar'})
-    assert err_parse_data.data == {'foo': 'bar'}
+def test_message_to_dict_preserves_structure():
+    """Test that MessageToDict produces correct structure."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-123')
+    msg.parts.append(Part(text='Hello'))
 
-    with pytest.raises(ValidationError):  # Wrong code
-        JSONParseError(code=-32000, message='Invalid JSON payload')  # type: ignore
+    msg_dict = MessageToDict(msg)
+    assert msg_dict['role'] == 'ROLE_USER'
+    assert msg_dict['messageId'] == 'msg-123'
+    # Part.text is a direct string field in proto
+    assert msg_dict['parts'][0]['text'] == 'Hello'
 
-    JSONParseError(code=-32700, message='Invalid JSON payload', extra='extra')  # type: ignore
 
+# --- Test Proto Copy and Equality ---
 
-def test_task_not_cancelable_error():
-    # Test TaskNotCancelableError
-    err_parse = TaskNotCancelableError()
-    assert err_parse.code == -32002
-    assert err_parse.message == 'Task cannot be canceled'
-    assert err_parse.data is None
 
-    err_parse_data = JSONParseError(
-        data={'foo': 'bar'}, message='not cancelled'
+def test_proto_copy():
+    """Test copying proto messages."""
+    original = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
     )
-    assert err_parse_data.data == {'foo': 'bar'}
-    assert err_parse_data.message == 'not cancelled'
 
-    with pytest.raises(ValidationError):  # Wrong code
-        JSONParseError(code=-32000, message='Task cannot be canceled')  # type: ignore
+    # Copy using CopyFrom
+    copy = Task()
+    copy.CopyFrom(original)
 
-    JSONParseError(
-        code=-32700,
-        message='Task cannot be canceled',
-        extra='extra',  # type: ignore
-    )
+    assert copy.id == 'task-123'
+    assert copy.context_id == 'ctx-456'
+    assert copy.status.state == TaskState.TASK_STATE_SUBMITTED
 
+    # Modifying copy doesn't affect original
+    copy.id = 'task-999'
+    assert original.id == 'task-123'
 
-def test_unsupported_operation_error():
-    # Test UnsupportedOperationError
-    err_parse = UnsupportedOperationError()
-    assert err_parse.code == -32004
-    assert err_parse.message == 'This operation is not supported'
-    assert err_parse.data is None
 
-    err_parse_data = JSONParseError(
-        data={'foo': 'bar'}, message='not supported'
+def test_proto_equality():
+    """Test proto message equality."""
+    task1 = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
+    )
+    task2 = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
     )
-    assert err_parse_data.data == {'foo': 'bar'}
-    assert err_parse_data.message == 'not supported'
-
-    with pytest.raises(ValidationError):  # Wrong code
-        JSONParseError(code=-32000, message='Unsupported')  # type: ignore
 
-    JSONParseError(code=-32700, message='Unsupported', extra='extra')  # type: ignore
+    assert task1 == task2
 
+    task2.id = 'task-999'
+    assert task1 != task2
 
-# --- Test TaskIdParams ---
 
+# --- Test HasField for Optional Fields ---
 
-def test_task_id_params_valid():
-    """Tests successful validation of TaskIdParams."""
-    # Minimal valid data
-    params_min = TaskIdParams(**MINIMAL_TASK_ID_PARAMS)
-    assert params_min.id == 'task-123'
-    assert params_min.metadata is None
 
-    # Full valid data
-    params_full = TaskIdParams(**FULL_TASK_ID_PARAMS)
-    assert params_full.id == 'task-456'
-    assert params_full.metadata == {'source': 'test'}
+def test_has_field_optional():
+    """Test HasField for checking optional field presence."""
+    status = TaskStatus(state=TaskState.TASK_STATE_SUBMITTED)
+    assert not status.HasField('message')
 
+    # Add message
+    msg = Message(role=Role.ROLE_USER, message_id='msg-1')
+    status.message.CopyFrom(msg)
+    assert status.HasField('message')
 
-def test_task_id_params_invalid():
-    """Tests validation errors for TaskIdParams."""
-    # Missing required 'id' field
-    with pytest.raises(ValidationError) as excinfo_missing:
-        TaskIdParams()  # type: ignore
-    assert 'id' in str(
-        excinfo_missing.value
-    )  # Check that 'id' is mentioned in the error
 
-    invalid_data = MINIMAL_TASK_ID_PARAMS.copy()
-    invalid_data['extra_field'] = 'allowed'
-    TaskIdParams(**invalid_data)  # type: ignore
+def test_has_field_oneof():
+    """Test HasField for oneof fields."""
+    part = Part(text='Hello')
+    assert part.HasField('text')
+    assert not part.HasField('url')
+    assert not part.HasField('data')
 
-    # Incorrect type for metadata (should be dict)
-    invalid_metadata_type = {'id': 'task-789', 'metadata': 'not_a_dict'}
-    with pytest.raises(ValidationError) as excinfo_type:
-        TaskIdParams(**invalid_metadata_type)  # type: ignore
-    assert 'metadata' in str(
-        excinfo_type.value
-    )  # Check that 'metadata' is mentioned
+    # WhichOneof for checking which oneof is set
+    assert part.WhichOneof('content') == 'text'
 
 
-def test_task_push_notification_config() -> None:
-    """Tests successful validation of TaskPushNotificationConfig."""
-    auth_info_dict: dict[str, Any] = {
-        'schemes': ['Bearer', 'Basic'],
-        'credentials': 'user:pass',
-    }
-    auth_info = PushNotificationAuthenticationInfo(**auth_info_dict)
+# --- Test Repeated Fields ---
 
-    push_notification_config = PushNotificationConfig(
-        url='https://example.com', token='token', authentication=auth_info
-    )
-    assert push_notification_config.url == 'https://example.com'
-    assert push_notification_config.token == 'token'
-    assert push_notification_config.authentication == auth_info
 
-    task_push_notification_config = TaskPushNotificationConfig(
-        taskId='task-123', pushNotificationConfig=push_notification_config
-    )
-    assert task_push_notification_config.taskId == 'task-123'
-    assert (
-        task_push_notification_config.pushNotificationConfig
-        == push_notification_config
+def test_repeated_field_operations():
+    """Test operations on repeated fields."""
+    task = Task(
+        id='task-123',
+        context_id='ctx-456',
+        status=TaskStatus(state=TaskState.TASK_STATE_SUBMITTED),
     )
-    assert task_push_notification_config.model_dump(exclude_none=True) == {
-        'taskId': 'task-123',
-        'pushNotificationConfig': {
-            'url': 'https://example.com',
-            'token': 'token',
-            'authentication': {
-                'schemes': ['Bearer', 'Basic'],
-                'credentials': 'user:pass',
-            },
-        },
-    }
 
+    # append
+    msg1 = Message(role=Role.ROLE_USER, message_id='msg-1')
+    task.history.append(msg1)
+    assert len(task.history) == 1
 
-def test_jsonrpc_message_valid():
-    """Tests successful validation of JSONRPCMessage."""
-    # With string ID
-    msg_str_id = JSONRPCMessage(jsonrpc='2.0', id='req-1')
-    assert msg_str_id.jsonrpc == '2.0'
-    assert msg_str_id.id == 'req-1'
+    # extend
+    msg2 = Message(role=Role.ROLE_AGENT, message_id='msg-2')
+    msg3 = Message(role=Role.ROLE_USER, message_id='msg-3')
+    task.history.extend([msg2, msg3])
+    assert len(task.history) == 3
 
-    # With integer ID (will be coerced to float by Pydantic for JSON number compatibility)
-    msg_int_id = JSONRPCMessage(jsonrpc='2.0', id=1)
-    assert msg_int_id.jsonrpc == '2.0'
-    assert (
-        msg_int_id.id == 1
-    )  # Pydantic v2 keeps int if possible, but float is in type hint
+    # iteration
+    roles = [m.role for m in task.history]
+    assert roles == [Role.ROLE_USER, Role.ROLE_AGENT, Role.ROLE_USER]
 
-    rpc_message = JSONRPCMessage(id=1)
-    assert rpc_message.jsonrpc == '2.0'
-    assert rpc_message.id == 1
 
+def test_map_field_operations():
+    """Test operations on map fields."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-1')
 
-def test_jsonrpc_message_invalid():
-    """Tests validation errors for JSONRPCMessage."""
-    # Incorrect jsonrpc version
-    with pytest.raises(ValidationError):
-        JSONRPCMessage(jsonrpc='1.0', id=1)  # type: ignore
+    # Update map
+    msg.metadata.update({'key1': 'value1', 'key2': 'value2'})
+    assert dict(msg.metadata) == {'key1': 'value1', 'key2': 'value2'}
 
-    JSONRPCMessage(jsonrpc='2.0', id=1, extra_field='extra')  # type: ignore
+    # Access individual keys
+    assert msg.metadata['key1'] == 'value1'
 
-    # Invalid ID type (e.g., list) - Pydantic should catch this based on type hints
-    with pytest.raises(ValidationError):
-        JSONRPCMessage(jsonrpc='2.0', id=[1, 2])  # type: ignore
+    # Check containment
+    assert 'key1' in msg.metadata
+    assert 'key3' not in msg.metadata
 
 
-def test_file_base_valid():
-    """Tests successful validation of FileBase."""
-    # No optional fields
-    base1 = FileBase()
-    assert base1.mimeType is None
-    assert base1.name is None
+# --- Test Serialization ---
 
-    # With mimeType only
-    base2 = FileBase(mimeType='image/png')
-    assert base2.mimeType == 'image/png'
-    assert base2.name is None
 
-    # With name only
-    base3 = FileBase(name='document.pdf')
-    assert base3.mimeType is None
-    assert base3.name == 'document.pdf'
+def test_serialize_to_bytes():
+    """Test serializing proto to bytes."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-123')
+    msg.parts.append(Part(text='Hello'))
 
-    # With both fields
-    base4 = FileBase(mimeType='application/json', name='data.json')
-    assert base4.mimeType == 'application/json'
-    assert base4.name == 'data.json'
+    # Serialize
+    data = msg.SerializeToString()
+    assert isinstance(data, bytes)
+    assert len(data) > 0
 
+    # Deserialize
+    msg2 = Message()
+    msg2.ParseFromString(data)
+    assert msg2.role == Role.ROLE_USER
+    assert msg2.message_id == 'msg-123'
+    assert msg2.parts[0].text == 'Hello'
 
-def test_file_base_invalid():
-    """Tests validation errors for FileBase."""
-    FileBase(extra_field='allowed')  # type: ignore
 
-    # Incorrect type for mimeType
-    with pytest.raises(ValidationError) as excinfo_type_mime:
-        FileBase(mimeType=123)  # type: ignore
-    assert 'mimeType' in str(excinfo_type_mime.value)
+def test_serialize_to_json():
+    """Test serializing proto to JSON via MessageToDict."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-123')
+    msg.parts.append(Part(text='Hello'))
 
-    # Incorrect type for name
-    with pytest.raises(ValidationError) as excinfo_type_name:
-        FileBase(name=['list', 'is', 'wrong'])  # type: ignore
-    assert 'name' in str(excinfo_type_name.value)
+    # MessageToDict for JSON-serializable dict
+    msg_dict = MessageToDict(msg)
 
+    import json
 
-def test_part_base_valid() -> None:
-    """Tests successful validation of PartBase."""
-    # No optional fields (metadata is None)
-    base1 = PartBase()
-    assert base1.metadata is None
+    json_str = json.dumps(msg_dict)
+    assert 'ROLE_USER' in json_str
+    assert 'msg-123' in json_str
 
-    # With metadata
-    meta_data: dict[str, Any] = {'source': 'test', 'timestamp': 12345}
-    base2 = PartBase(metadata=meta_data)
-    assert base2.metadata == meta_data
 
+# --- Test Default Values ---
 
-def test_part_base_invalid():
-    """Tests validation errors for PartBase."""
-    PartBase(extra_field='allowed')  # type: ignore
 
-    # Incorrect type for metadata (should be dict)
-    with pytest.raises(ValidationError) as excinfo_type:
-        PartBase(metadata='not_a_dict')  # type: ignore
-    assert 'metadata' in str(excinfo_type.value)
+def test_default_values():
+    """Test proto default values."""
+    # Empty message has defaults
+    msg = Message()
+    assert msg.role == Role.ROLE_UNSPECIFIED  # Enum default is 0
+    assert msg.message_id == ''  # String default is empty
+    assert len(msg.parts) == 0  # Repeated field default is empty
 
+    # Task status defaults
+    status = TaskStatus()
+    assert status.state == TaskState.TASK_STATE_UNSPECIFIED
+    assert status.timestamp.seconds == 0  # Timestamp proto default
 
-def test_a2a_error_validation_and_serialization() -> None:
-    """Tests validation and serialization of the A2AError RootModel."""
 
-    # 1. Test JSONParseError
-    json_parse_instance = JSONParseError()
-    json_parse_data = json_parse_instance.model_dump(exclude_none=True)
-    a2a_err_parse = A2AError.model_validate(json_parse_data)
-    assert isinstance(a2a_err_parse.root, JSONParseError)
+def test_clear_field():
+    """Test clearing fields."""
+    msg = Message(role=Role.ROLE_USER, message_id='msg-123')
+    assert msg.message_id == 'msg-123'
 
-    # 2. Test InvalidRequestError
-    invalid_req_instance = InvalidRequestError()
-    invalid_req_data = invalid_req_instance.model_dump(exclude_none=True)
-    a2a_err_invalid_req = A2AError.model_validate(invalid_req_data)
-    assert isinstance(a2a_err_invalid_req.root, InvalidRequestError)
+    msg.ClearField('message_id')
+    assert msg.message_id == ''  # Back to default
 
-    # 3. Test MethodNotFoundError
-    method_not_found_instance = MethodNotFoundError()
-    method_not_found_data = method_not_found_instance.model_dump(
-        exclude_none=True
-    )
-    a2a_err_method = A2AError.model_validate(method_not_found_data)
-    assert isinstance(a2a_err_method.root, MethodNotFoundError)
-
-    # 4. Test InvalidParamsError
-    invalid_params_instance = InvalidParamsError()
-    invalid_params_data = invalid_params_instance.model_dump(exclude_none=True)
-    a2a_err_params = A2AError.model_validate(invalid_params_data)
-    assert isinstance(a2a_err_params.root, InvalidParamsError)
-
-    # 5. Test InternalError
-    internal_err_instance = InternalError()
-    internal_err_data = internal_err_instance.model_dump(exclude_none=True)
-    a2a_err_internal = A2AError.model_validate(internal_err_data)
-    assert isinstance(a2a_err_internal.root, InternalError)
-
-    # 6. Test TaskNotFoundError
-    task_not_found_instance = TaskNotFoundError(data={'taskId': 't1'})
-    task_not_found_data = task_not_found_instance.model_dump(exclude_none=True)
-    a2a_err_task_nf = A2AError.model_validate(task_not_found_data)
-    assert isinstance(a2a_err_task_nf.root, TaskNotFoundError)
-
-    # 7. Test TaskNotCancelableError
-    task_not_cancelable_instance = TaskNotCancelableError()
-    task_not_cancelable_data = task_not_cancelable_instance.model_dump(
-        exclude_none=True
-    )
-    a2a_err_task_nc = A2AError.model_validate(task_not_cancelable_data)
-    assert isinstance(a2a_err_task_nc.root, TaskNotCancelableError)
-
-    # 8. Test PushNotificationNotSupportedError
-    push_not_supported_instance = PushNotificationNotSupportedError()
-    push_not_supported_data = push_not_supported_instance.model_dump(
-        exclude_none=True
-    )
-    a2a_err_push_ns = A2AError.model_validate(push_not_supported_data)
-    assert isinstance(a2a_err_push_ns.root, PushNotificationNotSupportedError)
-
-    # 9. Test UnsupportedOperationError
-    unsupported_op_instance = UnsupportedOperationError()
-    unsupported_op_data = unsupported_op_instance.model_dump(exclude_none=True)
-    a2a_err_unsupported = A2AError.model_validate(unsupported_op_data)
-    assert isinstance(a2a_err_unsupported.root, UnsupportedOperationError)
-
-    # 10. Test ContentTypeNotSupportedError
-    content_type_err_instance = ContentTypeNotSupportedError()
-    content_type_err_data = content_type_err_instance.model_dump(
-        exclude_none=True
-    )
-    a2a_err_content = A2AError.model_validate(content_type_err_data)
-    assert isinstance(a2a_err_content.root, ContentTypeNotSupportedError)
+    # Clear nested message
+    status = TaskStatus(state=TaskState.TASK_STATE_WORKING)
+    status.message.CopyFrom(Message(role=Role.ROLE_USER))
+    assert status.HasField('message')
 
-    # 11. Test invalid data (doesn't match any known error code/structure)
-    invalid_data: dict[str, Any] = {'code': -99999, 'message': 'Unknown error'}
-    with pytest.raises(ValidationError):
-        A2AError.model_validate(invalid_data)
+    status.ClearField('message')
+    assert not status.HasField('message')
diff --git a/tests/utils/jcs_depth_vectors.json b/tests/utils/jcs_depth_vectors.json
new file mode 100644
index 000000000..168b0c7c3
--- /dev/null
+++ b/tests/utils/jcs_depth_vectors.json
@@ -0,0 +1,227 @@
+{
+  "corpus": "jcs_depth_v1",
+  "suite": "a2a-agent-card-signature-conformance",
+  "layer": "nesting-bound",
+  "specRef": "https://www.rfc-editor.org/rfc/rfc8785 (no nesting limit stated) and https://a2aproject.org/specification/#841-canonicalization-requirements",
+  "scope": "The input a canonicalizer must refuse. RFC 8785 pins the bytes a canonicalizer must produce and states no bound on how deeply an input may nest, so two implementations that agree on every byte-level vector can still disagree on whether a deep artifact canonicalizes at all. Canonicalization runs before signature verification, so the walk is reachable without a key.",
+  "max_depth": 128,
+  "depth_counting_rule": "Depth counts OPEN CONTAINERS: the outermost brace or bracket is depth 1, and every object or array opened inside it adds one, an empty container included. A counter that charges a level per parsed child instead never charges an empty container and lands one level off - which is what the empty-container vectors separate.",
+  "reference_impl": "Python rfc8785 0.1.4 (Trail of Bits)",
+  "attribution": {
+    "corpus": "jcs_depth_v1",
+    "author": "Sankalp Gilda",
+    "license": "Apache-2.0",
+    "upstream": "https://github.com/a2aproject/A2A/pull/2246 (proposals/content-integrity-profile/vectors/jcs_depth_v1)",
+    "source_corpus": {
+      "name": "agent-evidence-vectors",
+      "suite": "adversarial-execution-evidence-conformance",
+      "repository": "https://github.com/astrogilda/agent-evidence-vectors"
+    },
+    "note": "Retained as published: every expected byte string was produced by canonicalising the materialised preimage with the reference implementation above, and all preimage digests are checked before any expectation is used."
+  },
+  "preimage_rule_form": {
+    "note": "Preimages are given as nesting rules rather than literal JSON so this file stays four levels deep and can be read by a parser that enforces the bound it describes. Materialise as text: for i from 0 to count-1 emit the opener for containers[i % len(containers)] ('{\"a\":' for object, '[' for array), then emit leaf, then emit the matching closers innermost-first.",
+    "openers": {
+      "object": "{\"a\":",
+      "array": "["
+    },
+    "closers": {
+      "object": "}",
+      "array": "]"
+    }
+  },
+  "vectors": [
+    {
+      "vector_id": "jcs-depth-001-object-at-bound",
+      "description": "128 nested objects, the deepest input the bound admits. A canonicaliser that applies the bound one level early refuses this and is off by one.",
+      "outcome": "accept",
+      "depth": 128,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "object"
+        ],
+        "count": 128,
+        "leaf": "1"
+      },
+      "preimage_bytes": 769,
+      "preimage_sha256": "a4908c65856c2fb1e94d6b2b55620177bd082f54d43252b9e0648f9ccd53e3fe",
+      "expected_jcs_bytes_b64": "eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOjF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fQ==",
+      "expected_sha256": "a4908c65856c2fb1e94d6b2b55620177bd082f54d43252b9e0648f9ccd53e3fe",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-002-array-at-bound",
+      "description": "128 nested arrays at the bound. Separated from the object case because a depth counter placed only in the object branch never charges an array.",
+      "outcome": "accept",
+      "depth": 128,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "array"
+        ],
+        "count": 128,
+        "leaf": "1"
+      },
+      "preimage_bytes": 257,
+      "preimage_sha256": "68da6c21da4d39e99f241a56379e98c2053372e77cd74f72400af6d3a37261c3",
+      "expected_jcs_bytes_b64": "W1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1sxXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV0=",
+      "expected_sha256": "68da6c21da4d39e99f241a56379e98c2053372e77cd74f72400af6d3a37261c3",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-003-alternating-at-bound",
+      "description": "128 containers alternating object, array, object, array at the bound. Catches a counter that tracks one container kind and resets on the other.",
+      "outcome": "accept",
+      "depth": 128,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "object",
+          "array"
+        ],
+        "count": 128,
+        "leaf": "1"
+      },
+      "preimage_bytes": 513,
+      "preimage_sha256": "aa4e4f042129f600f2352f2ecd58559409175fd83cf4918c382afc3d33942268",
+      "expected_jcs_bytes_b64": "eyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbeyJhIjpbMV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19XX1dfV19",
+      "expected_sha256": "aa4e4f042129f600f2352f2ecd58559409175fd83cf4918c382afc3d33942268",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-004-empty-object-leaf-at-bound",
+      "description": "127 wrapping objects around an empty object. The empty container is itself the 128th open container, so this sits exactly at the bound and is accepted.",
+      "outcome": "accept",
+      "depth": 128,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "object"
+        ],
+        "count": 127,
+        "leaf": "{}"
+      },
+      "preimage_bytes": 764,
+      "preimage_sha256": "95abadd19f4a27dd41c2e3b46baca7320d039f4e4686fcdaebb0a7d7146bb16e",
+      "expected_jcs_bytes_b64": "eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7ImEiOnsiYSI6eyJhIjp7fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX0=",
+      "expected_sha256": "95abadd19f4a27dd41c2e3b46baca7320d039f4e4686fcdaebb0a7d7146bb16e",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-101-object-one-past-bound",
+      "description": "129 nested objects, one level past the bound. Differs from jcs-depth-001-object-at-bound by exactly one wrapping object.",
+      "outcome": "reject",
+      "depth": 129,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "object"
+        ],
+        "count": 129,
+        "leaf": "1"
+      },
+      "preimage_bytes": 775,
+      "preimage_sha256": "eeb23e8c9c090d0303063348ae7ca4a5914992972fc20e295e8e386802e2a95a",
+      "trace": {
+        "corpus": "agent-evidence-vectors",
+        "sibling_vector_id": "v08251931ec038e91"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-102-array-one-past-bound",
+      "description": "129 nested arrays, one level past the bound.",
+      "outcome": "reject",
+      "depth": 129,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "array"
+        ],
+        "count": 129,
+        "leaf": "1"
+      },
+      "preimage_bytes": 259,
+      "preimage_sha256": "84aaf90be3265f8e148bdcc72153a59156d358f74e3dedd2d6a5dd566f5944f5",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-103-empty-object-leaf-one-past-bound",
+      "description": "128 wrapping objects around an empty object: open-container depth 129, one past the bound. This is the case a scalar leaf cannot discriminate. A canonicaliser that charges a level per parsed child rather than per opened container never charges the empty object, reads this as depth 128 and accepts it while refusing jcs-depth-101-object-one-past-bound.",
+      "outcome": "reject",
+      "depth": 129,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "object"
+        ],
+        "count": 128,
+        "leaf": "{}"
+      },
+      "preimage_bytes": 770,
+      "preimage_sha256": "47ec83edd0d185f58e09a843867e31af9088c4da554f55c730c52f547161a8b1",
+      "trace": {
+        "corpus": "agent-evidence-vectors",
+        "sibling_vector_id": "v83f4b7fe6068ef86"
+      }
+    },
+    {
+      "vector_id": "jcs-depth-104-deep-input-refused-not-crashed",
+      "description": "500 nested arrays: well past the bound, but shallow enough that the JSON decoder accepts the input (CPython's decoder recurses to about 1000 levels), so the refusal has to come from the depth bound and reach the caller as a catchable rejection rather than as a decoder failure or a stack crash. A payload of ten million levels does not test that: json.loads refuses it before canonicalization is entered at all, so the vector would pin the decoder's own recursion limit instead of the bound.",
+      "outcome": "reject",
+      "depth": 500,
+      "preimage_rule": {
+        "form": "nest",
+        "containers": [
+          "array"
+        ],
+        "count": 500,
+        "leaf": "1"
+      },
+      "preimage_bytes": 1001,
+      "preimage_sha256": "a655facd9262ddb5ddf32b1f4f8d937fb2ded910b13fe7f12c44abb2783756eb",
+      "trace": {
+        "corpus": "agent-evidence-vectors"
+      }
+    }
+  ],
+  "pair_invariants": [
+    {
+      "name": "object_bound_is_exact",
+      "a": "jcs-depth-001-object-at-bound",
+      "b": "jcs-depth-101-object-one-past-bound",
+      "relation": "accept_then_reject",
+      "why": "The two inputs differ by one wrapping object. An implementation that accepts both has no bound; one that refuses both has the bound off by one. Only the pair locates it."
+    },
+    {
+      "name": "array_bound_is_exact",
+      "a": "jcs-depth-002-array-at-bound",
+      "b": "jcs-depth-102-array-one-past-bound",
+      "relation": "accept_then_reject",
+      "why": "The same boundary in the array branch, which a counter placed only in the object branch never reaches."
+    },
+    {
+      "name": "empty_container_charges_a_level",
+      "a": "jcs-depth-004-empty-object-leaf-at-bound",
+      "b": "jcs-depth-103-empty-object-leaf-one-past-bound",
+      "relation": "accept_then_reject",
+      "why": "A per-child counter never charges an empty container, so it reads the second input as depth 128 and accepts it. Both scalar-leaf vectors pass under that counter, which is why this pair exists."
+    },
+    {
+      "name": "refusal_is_not_a_crash",
+      "vector": "jcs-depth-104-deep-input-refused-not-crashed",
+      "relation": "reject_without_stack_exhaustion",
+      "why": "The vector is passed only if the implementation returns a rejection to its caller. A process that dies on this input has not rejected it, and a crash on an unauthenticated artifact is the outcome the bound exists to prevent."
+    }
+  ]
+}
diff --git a/tests/utils/jcs_vectors.json b/tests/utils/jcs_vectors.json
new file mode 100644
index 000000000..cfe59c842
--- /dev/null
+++ b/tests/utils/jcs_vectors.json
@@ -0,0 +1,685 @@
+{
+  "_comment": "RFC 8785 (JCS) conformance vectors for Agent Card canonicalization. Lifted verbatim from the language-neutral a2a-jcs-v01 corpus proposed at https://github.com/a2aproject/a2a-tck/pull/228 . Each expected value was produced by two independent RFC 8785 implementations written by neither SDK author (rfc8785 0.1.4 on PyPI, and gowebpki/jcs v1.0.1 in Go), which agree byte for byte.",
+  "corpus": "a2a-jcs-v01",
+  "specRef": "https://a2a-protocol.org/latest/specification/#841-canonicalization-requirements",
+  "oracles": [
+    "rfc8785 (PyPI, 0.1.4)",
+    "gowebpki/jcs (Go, v1.0.1)"
+  ],
+  "counts": {
+    "accept": 47,
+    "reject": 10,
+    "total": 57
+  },
+  "vectors": [
+    {
+      "id": "A2-001",
+      "group": "a2-signatures-exclusion",
+      "clause": "a2a-spec-8.4.1-rule-3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A card carrying a populated `signatures` array canonicalizes as if that key were absent entirely; the exclusion is unconditional, not conditional on the array being empty.",
+      "input": {
+        "name": "Example Agent",
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiJ9",
+            "signature": "abc123"
+          }
+        ]
+      },
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c226e616d65223a224578616d706c65204167656e74227d"
+    },
+    {
+      "id": "A2-002",
+      "group": "a2-signatures-exclusion",
+      "clause": "a2a-spec-8.4.1-rule-3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A card carrying an EMPTY `signatures` array ([]) is excluded the same way as a populated one (A2-001): exclusion is by key presence, not by whether the value is 'interesting'. Compare directly against A6-001, which established that an empty array is otherwise a perfectly normal RFC 8785 value elsewhere in a document -- the only thing special about `signatures` is the key name.",
+      "input": {
+        "name": "Example Agent",
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "signatures": []
+      },
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c226e616d65223a224578616d706c65204167656e74227d"
+    },
+    {
+      "id": "A2-REJECT-003",
+      "group": "a2-signatures-exclusion",
+      "clause": "a2a-spec-8.4.1-rule-3",
+      "disposition": "MUST-REJECT",
+      "rationale": "A single-signature payload presented as canonical output but still carrying its own `signatures` array is self-referential: the bytes a signature covers cannot include the signature that covers them, so any canonical form containing `signatures` is definitionally wrong regardless of what RFC 8785 alone would say about it. (confirmed: the input below is valid, well-formed JSON that parses cleanly -- both RFC 8785 oracles would canonicalize it without complaint -- and is refused ONLY because it retains the excluded key, which is an a2a-specific rule RFC 8785 itself has no opinion on.)",
+      "input_raw": "{\"capabilities\":{\"pushNotifications\":false,\"streaming\":true},\"name\":\"Example Agent\",\"signatures\":[{\"protected\":\"eyJhbGciOiJFUzI1NiJ9\",\"signature\":\"abc123\"}]}"
+    },
+    {
+      "id": "A2-REJECT-004",
+      "group": "a2-signatures-exclusion",
+      "clause": "a2a-spec-8.4.1-rule-3",
+      "disposition": "MUST-REJECT",
+      "rationale": "Even a `signatures` key holding an empty array must still be rejected in claimed-canonical output: the exclusion rule is unconditional (A2-002), so its violation is unconditional too -- an empty array does not make the self-reference acceptable, it is still the wrong key present in the wrong place. (confirmed: the input below is valid, well-formed JSON that parses cleanly -- both RFC 8785 oracles would canonicalize it without complaint -- and is refused ONLY because it retains the excluded key, which is an a2a-specific rule RFC 8785 itself has no opinion on.)",
+      "input_raw": "{\"capabilities\":{\"pushNotifications\":false,\"streaming\":true},\"name\":\"Example Agent\",\"signatures\":[]}"
+    },
+    {
+      "id": "A3-001",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Baseline: keys already in UTF-16 code-unit order pass through unchanged.",
+      "input": {
+        "a": 1,
+        "b": 2,
+        "c": 3
+      },
+      "canonical_utf8_hex": "7b2261223a312c2262223a322c2263223a337d"
+    },
+    {
+      "id": "A3-002",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Keys given out of order must be reordered to UTF-16 code-unit order.",
+      "input": {
+        "zebra": 1,
+        "apple": 2,
+        "mango": 3
+      },
+      "canonical_utf8_hex": "7b226170706c65223a322c226d616e676f223a332c227a65627261223a317d"
+    },
+    {
+      "id": "A3-003",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Case sensitivity: uppercase ASCII (U+0041 'A') sorts before lowercase ASCII (U+0061 'a') as a raw code unit.",
+      "input": {
+        "apple": 1,
+        "Apple": 2
+      },
+      "canonical_utf8_hex": "7b224170706c65223a322c226170706c65223a317d"
+    },
+    {
+      "id": "A3-004",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Numeric-looking keys sort as UTF-16 code-unit sequences, not as numbers: '1' < '10' < '2'.",
+      "input": {
+        "10": 1,
+        "2": 2,
+        "1": 3
+      },
+      "canonical_utf8_hex": "7b2231223a332c223130223a312c2232223a327d"
+    },
+    {
+      "id": "A3-005",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A BMP character above the ASCII range (U+00E9 'e with acute') sorts after every ASCII key.",
+      "input": {
+        "cafe": 1,
+        "caf\u00e9": 2
+      },
+      "canonical_utf8_hex": "7b2263616665223a312c22636166c3a9223a327d"
+    },
+    {
+      "id": "A3-006",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The a2aproject/A2A#2122 counterexample verbatim (case C3): a key containing U+1F600 (surrogate pair D83D DE00) sorts BEFORE a key containing U+FF01 (single unit FF01), because D83D < FF01 as raw UTF-16 code units, even though the code POINT 1F600 is numerically greater than FF01. Sorting by code point instead of UTF-16 code unit -- what a2a-python's sort_keys=True does -- gets this pair backwards.",
+      "input": {
+        "b\ud83d\ude00key": 1,
+        "b\uff01key": 2
+      },
+      "canonical_utf8_hex": "7b2262f09f98806b6579223a312c2262efbc816b6579223a327d"
+    },
+    {
+      "id": "A3-007",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A second astral-vs-high-BMP inversion pair, generalizing A3-006 beyond one example: U+10000 (surrogate pair D800 DC00) sorts before U+E000 (single unit E000, Private Use Area) by the same UTF-16-vs-code-point divergence.",
+      "input": {
+        "x\ud800\udc00end": 1,
+        "x\ue000end": 2
+      },
+      "canonical_utf8_hex": "7b2278f0908080656e64223a312c2278ee8080656e64223a327d"
+    },
+    {
+      "id": "A3-008",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Two byte-distinct keys that render identically to a human (precomposed U+00E9 vs the combining-character sequence 'e' + U+0301) are different code-unit sequences with no normalization applied by RFC 8785; they sort as the distinct sequences they are, and the combining form (starts with plain ASCII 'e', U+0065) sorts before the precomposed form (starts with U+00E9).",
+      "input": {
+        "caf\u00e9": 1,
+        "cafe\u0301": 2
+      },
+      "canonical_utf8_hex": "7b2263616665cc81223a322c22636166c3a9223a317d"
+    },
+    {
+      "id": "A3-009",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The empty string is a valid key and, having zero code units, sorts before every non-empty key.",
+      "input": {
+        "": 1,
+        "a": 2
+      },
+      "canonical_utf8_hex": "7b22223a312c2261223a327d"
+    },
+    {
+      "id": "A3-010",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Stress case: eleven keys spanning ASCII, digits and mixed case sorted together, confirming the ordering rule is stable across more than a handful of keys at once.",
+      "input": {
+        "Zulu": 1,
+        "alpha": 2,
+        "Bravo": 3,
+        "charlie": 4,
+        "Delta": 5,
+        "9key": 6,
+        "echo": 7,
+        "Foxtrot": 8,
+        "1key": 9,
+        "golf": 10,
+        "Hotel": 11
+      },
+      "canonical_utf8_hex": "7b22316b6579223a392c22396b6579223a362c22427261766f223a332c2244656c7461223a352c22466f7874726f74223a382c22486f74656c223a31312c225a756c75223a312c22616c706861223a322c22636861726c6965223a342c226563686f223a372c22676f6c66223a31307d"
+    },
+    {
+      "id": "A3-REJECT-011",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-REJECT",
+      "rationale": "A key containing a lone (unpaired) high surrogate U+D800 with no following low surrogate is not valid Unicode text and has no well-formed UTF-8 encoding, so it cannot be assigned a UTF-16 code-unit sort position or emitted as literal UTF-8 (RFC 8785 sect. 3.2.2.2); a conformant canonicalizer must refuse it rather than silently pass the unpaired surrogate through or substitute a replacement character. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"b\\ud800key\": 1, \"a\": 2}"
+    },
+    {
+      "id": "A3-REJECT-012",
+      "group": "a3-object-key-ordering",
+      "clause": "RFC8785-3.2.3",
+      "disposition": "MUST-REJECT",
+      "rationale": "A key containing a lone (unpaired) LOW surrogate U+DC00 with no preceding high surrogate completes A3-REJECT-011's high-surrogate case with the low-surrogate half of the pair: equally invalid Unicode, equally unencodable as well-formed UTF-8, for the same reason. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"b\\udc00key\": 1, \"a\": 2}"
+    },
+    {
+      "id": "A4-001",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The a2aproject/A2A#2122 counterexample verbatim (case C2): a non-ASCII scalar (e with acute, U+00E9) is emitted as literal UTF-8 bytes, never as a \\u00e9 escape. ensure_ascii=True in Python's json.dumps -- a2a-python's actual default -- produces the escaped form and fails this vector.",
+      "input": {
+        "name": "Caf\u00e9 Agent",
+        "description": "Planifie des itin\u00e9raires."
+      },
+      "canonical_utf8_hex": "7b226465736372697074696f6e223a22506c616e6966696520646573206974696ec3a97261697265732e222c226e616d65223a22436166c3a9204167656e74227d"
+    },
+    {
+      "id": "A4-002",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Pure ASCII content is the trivial control case: no escaping needed, output equals input.",
+      "input": {
+        "name": "Example Agent"
+      },
+      "canonical_utf8_hex": "7b226e616d65223a224578616d706c65204167656e74227d"
+    },
+    {
+      "id": "A4-003",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "An astral-plane character (U+1F600 GRINNING FACE, outside the Basic Multilingual Plane, requiring a UTF-16 surrogate pair to represent but a single 4-byte UTF-8 sequence) is emitted as literal UTF-8, not as a \\ud83d\\ude00 surrogate-pair escape.",
+      "input": {
+        "note": "hello \ud83d\ude00 world"
+      },
+      "canonical_utf8_hex": "7b226e6f7465223a2268656c6c6f20f09f988020776f726c64227d"
+    },
+    {
+      "id": "A4-004",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The mandatory escape set is exactly quote, backslash, and control characters below U+0020: this string exercises all three (a literal quote, a literal backslash, and a literal newline), each of which MUST still be escaped even though non-ASCII text is emitted literally.",
+      "input": {
+        "raw": "a \"quoted\" \\ path\nwith a newline"
+      },
+      "canonical_utf8_hex": "7b22726177223a2261205c2271756f7465645c22205c5c20706174685c6e776974682061206e65776c696e65227d"
+    },
+    {
+      "id": "A4-005",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The empty string is a valid scalar value and serializes as a pair of quote characters with nothing between them.",
+      "input": {
+        "empty": ""
+      },
+      "canonical_utf8_hex": "7b22656d707479223a22227d"
+    },
+    {
+      "id": "A4-006",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Every remaining C0 control character (U+0001 through U+001F, excluding the ones with short escapes like \\n and \\t) must still be escaped as \\u00XX -- control-character escaping is required regardless of the literal-UTF-8 rule for ordinary text, since control characters are never literal in a JSON string.",
+      "input": {
+        "ctrl": "a\u0001b\u001fc"
+      },
+      "canonical_utf8_hex": "7b226374726c223a22615c7530303031625c753030316663227d"
+    },
+    {
+      "id": "A4-007",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A CJK ideograph (U+4E2D, three-byte UTF-8) is emitted as literal UTF-8, the same rule as A4-001 applied to a script outside the Latin-1 range.",
+      "input": {
+        "label": "\u4e2d\u6587"
+      },
+      "canonical_utf8_hex": "7b226c6162656c223a22e4b8ade69687227d"
+    },
+    {
+      "id": "A4-008",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "U+007F (DELETE) sits immediately above the printable ASCII range and below the C1 control block; RFC 8785 requires literal UTF-8 for it like any other non-mandatory-escape character, it is not part of the U+0000-U+001F mandatory escape set.",
+      "input": {
+        "del": "a\u007fb"
+      },
+      "canonical_utf8_hex": "7b2264656c223a22617f62227d"
+    },
+    {
+      "id": "A4-009",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A combining diacritic (U+0301 COMBINING ACUTE ACCENT) immediately following its base character is ordinary non-ASCII text with no special JSON-string handling; it is emitted as literal UTF-8 like any other codepoint outside the escape set.",
+      "input": {
+        "combining": "e\u0301clair"
+      },
+      "canonical_utf8_hex": "7b22636f6d62696e696e67223a2265cc81636c616972227d"
+    },
+    {
+      "id": "A4-010",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Right-to-left script content (Arabic, U+0627 ALEF through U+0629 TEH MARBUTA) is emitted as literal UTF-8 bytes; RFC 8785 has no bidi-aware transform, only byte identity.",
+      "input": {
+        "rtl": "\u0627\u0644\u0633\u0644\u0627\u0645"
+      },
+      "canonical_utf8_hex": "7b2272746c223a22d8a7d984d8b3d984d8a7d985227d"
+    },
+    {
+      "id": "A4-011",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Forward slash is explicitly NOT in JSON's mandatory escape set (unlike some JSON encoders' optional habit of escaping it as \\/) and must be emitted literally.",
+      "input": {
+        "url": "https://example.com/a2a/v1"
+      },
+      "canonical_utf8_hex": "7b2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d"
+    },
+    {
+      "id": "A4-012",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A string built entirely from two adjacent astral-plane characters (both requiring surrogate pairs in UTF-16) confirms multi-character non-BMP content is handled, not just a single isolated case like A4-003.",
+      "input": {
+        "emoji_pair": "\ud83d\ude00\ud83d\ude01"
+      },
+      "canonical_utf8_hex": "7b22656d6f6a695f70616972223a22f09f9880f09f9881227d"
+    },
+    {
+      "id": "A4-REJECT-013",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-REJECT",
+      "rationale": "A lone (unpaired) low surrogate U+DC00 inside a STRING VALUE (not a key, unlike A3-REJECT-011/012) is not valid Unicode text and has no well-formed UTF-8 encoding; a conformant canonicalizer must refuse it rather than emit an invalid byte sequence or silently substitute U+FFFD. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"name\": \"broken \\udc00 value\"}"
+    },
+    {
+      "id": "A4-REJECT-014",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-REJECT",
+      "rationale": "A lone low surrogate (U+DC00) embedded mid-string, with ordinary text both before and after it, is the string-value counterpart to A3-REJECT-012's key-position case: unpaired, not valid Unicode, no well-formed UTF-8 encoding, and unlike A4-REJECT-013's simpler isolated case this confirms the defect is caught with real surrounding content rather than only in a minimal reproduction. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"name\": \"before\\udc00after\"}"
+    },
+    {
+      "id": "A4-REJECT-015",
+      "group": "a4-string-serialization",
+      "clause": "RFC8785-3.2.2.2",
+      "disposition": "MUST-REJECT",
+      "rationale": "A high surrogate (U+D800) followed by an ordinary BMP character (a plain letter, not its matching low surrogate) leaves the high surrogate unpaired for exactly the same reason as A4-REJECT-013/014, just constructed a third way. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"name\": \"\\ud800x\"}"
+    },
+    {
+      "id": "A5-001",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The a2aproject/A2A#2122 counterexample verbatim (case C4): 0.000001 must serialize as the literal '0.000001', not as '1e-06' (Python's repr threshold, which is what a2a-python's json.dumps produces and what makes this a real cross-SDK break).",
+      "input": {
+        "tolerance": 1e-06
+      },
+      "canonical_utf8_hex": "7b22746f6c6572616e6365223a302e3030303030317d"
+    },
+    {
+      "id": "A5-002",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The a2aproject/A2A#2122 'big' companion value from the same case C4: 1e21 crosses the ECMAScript fixed/exponential boundary on the large-magnitude side and must serialize in exponential form.",
+      "input": {
+        "big": 1e+21
+      },
+      "canonical_utf8_hex": "7b22626967223a31652b32317d"
+    },
+    {
+      "id": "A5-003",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Positive integers serialize with no decimal point and no fractional zeros.",
+      "input": {
+        "n": 42
+      },
+      "canonical_utf8_hex": "7b226e223a34327d"
+    },
+    {
+      "id": "A5-004",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Negative integers keep the sign and otherwise follow the same integer rule.",
+      "input": {
+        "n": -17
+      },
+      "canonical_utf8_hex": "7b226e223a2d31377d"
+    },
+    {
+      "id": "A5-005",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Zero serializes as the bare digit '0'.",
+      "input": {
+        "n": 0
+      },
+      "canonical_utf8_hex": "7b226e223a307d"
+    },
+    {
+      "id": "A5-006",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Negative zero is a distinct IEEE 754 bit pattern from positive zero, but ECMAScript's Number::toString collapses both to the same string '0' -- there is no '-0' output form.",
+      "input": {
+        "n": -0.0
+      },
+      "canonical_utf8_hex": "7b226e223a307d"
+    },
+    {
+      "id": "A5-007",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "0.1 cannot be represented exactly in IEEE 754 double precision; ECMAScript's algorithm prints the shortest decimal digit sequence that round-trips back to the same double, not the full ~17-digit exact binary expansion.",
+      "input": {
+        "n": 0.1
+      },
+      "canonical_utf8_hex": "7b226e223a302e317d"
+    },
+    {
+      "id": "A5-008",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A five-significant-digit decimal exercises the shortest-round-trip rule on a value with more precision than 0.1.",
+      "input": {
+        "n": 3.14159
+      },
+      "canonical_utf8_hex": "7b226e223a332e31343135397d"
+    },
+    {
+      "id": "A5-009",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Number.MAX_SAFE_INTEGER (2^53 - 1): the largest integer every JS engine represents exactly, a natural boundary value for integer serialization.",
+      "input": {
+        "n": 9007199254740991
+      },
+      "canonical_utf8_hex": "7b226e223a393030373139393235343734303939317d"
+    },
+    {
+      "id": "A5-010",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A negative decimal combines the sign rule (A5-004) with fractional shortest-digit serialization (A5-007) in one value.",
+      "input": {
+        "n": -123.456
+      },
+      "canonical_utf8_hex": "7b226e223a2d3132332e3435367d"
+    },
+    {
+      "id": "A5-011",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "One order of magnitude below the a2aproject/A2A#2122 case C4 value (A5-001): 0.0000001 (1e-7) probes the small-magnitude side of the fixed/exponential boundary that 0.000001 sits just on the fixed side of.",
+      "input": {
+        "n": 1e-07
+      },
+      "canonical_utf8_hex": "7b226e223a31652d377d"
+    },
+    {
+      "id": "A5-012",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "One order of magnitude below the C4 'big' value (A5-002): 1e20 probes the large-magnitude side of the same boundary that 1e21 sits just past.",
+      "input": {
+        "n": 1e+20
+      },
+      "canonical_utf8_hex": "7b226e223a3130303030303030303030303030303030303030307d"
+    },
+    {
+      "id": "A5-013",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "0.1 + 0.2 in IEEE 754 double arithmetic does not equal 0.3; this is the resulting value (0.30000000000000004), a classic case requiring the full shortest-round-trip digit count rather than a short 'looks clean' rounding.",
+      "input": {
+        "n": 0.30000000000000004
+      },
+      "canonical_utf8_hex": "7b226e223a302e33303030303030303030303030303030347d"
+    },
+    {
+      "id": "A5-014",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "A round integer must not be printed in exponential form just because it has trailing zeros; 100 stays '100', not '1e2'.",
+      "input": {
+        "n": 100
+      },
+      "canonical_utf8_hex": "7b226e223a3130307d"
+    },
+    {
+      "id": "A5-015",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Input syntax is not preserved verbatim: '1E1' (uppercase E, RFC 8259 permits both cases) and a trailing '.0' both parse to the double values 10 and 1 respectively, and the canonical form is the ECMAScript string for that VALUE, not a copy of the input digit sequence -- this vector's input intentionally does not look like its output.",
+      "input": {
+        "exp_upper": 10.0,
+        "trailing_zero": 1.0
+      },
+      "canonical_utf8_hex": "7b226578705f7570706572223a31302c22747261696c696e675f7a65726f223a317d"
+    },
+    {
+      "id": "A5-REJECT-016",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-REJECT",
+      "rationale": "NaN is not a valid RFC 8259 JSON number and has no ECMAScript Number::toString representation as a JSON token; some lenient parsers accept the bare word NaN as a non-standard extension, but a conformant canonicalizer must refuse to emit it rather than pass the extension through. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"n\": NaN}"
+    },
+    {
+      "id": "A5-REJECT-017",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-REJECT",
+      "rationale": "Infinity is the positive-magnitude sibling of A5-REJECT-016: not valid JSON, no canonical representation, must be refused rather than passed through by any parser lenient enough to accept the bare word. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"n\": Infinity}"
+    },
+    {
+      "id": "A5-REJECT-018",
+      "group": "a5-number-serialization",
+      "clause": "RFC8785-3.2.2.3",
+      "disposition": "MUST-REJECT",
+      "rationale": "Negative infinity completes the set: same defect as A5-REJECT-017 with the sign flipped, confirming the rejection is not specific to the unsigned spelling. (confirmed refused by both independent oracles: go+py)",
+      "input_raw": "{\"n\": -Infinity}"
+    },
+    {
+      "id": "A6-001",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "An empty array is a valid value and serializes as '[]' with no whitespace.",
+      "input": {
+        "items": []
+      },
+      "canonical_utf8_hex": "7b226974656d73223a5b5d7d"
+    },
+    {
+      "id": "A6-002",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "An empty object is a valid value and serializes as '{}' with no whitespace.",
+      "input": {
+        "config": {}
+      },
+      "canonical_utf8_hex": "7b22636f6e666967223a7b7d7d"
+    },
+    {
+      "id": "A6-003",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Arrays preserve input order; RFC 8785 orders object keys, never array elements.",
+      "input": {
+        "matrix": [
+          [
+            1,
+            2
+          ],
+          [
+            3,
+            4
+          ]
+        ]
+      },
+      "canonical_utf8_hex": "7b226d6174726978223a5b5b312c325d2c5b332c345d5d7d"
+    },
+    {
+      "id": "A6-004",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Object nesting recurses the same key-ordering rule at every depth.",
+      "input": {
+        "a": {
+          "b": {
+            "c": 1
+          }
+        }
+      },
+      "canonical_utf8_hex": "7b2261223a7b2262223a7b2263223a317d7d7d"
+    },
+    {
+      "id": "A6-005",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "An array may mix every JSON primitive type; each element serializes per its own type's rule and array order is preserved regardless of type.",
+      "input": {
+        "mixed": [
+          1,
+          "two",
+          true,
+          false,
+          null,
+          3.5
+        ]
+      },
+      "canonical_utf8_hex": "7b226d69786564223a5b312c2274776f222c747275652c66616c73652c6e756c6c2c332e355d7d"
+    },
+    {
+      "id": "A6-006",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "The null literal serializes as the bare token 'null'.",
+      "input": {
+        "value": null
+      },
+      "canonical_utf8_hex": "7b2276616c7565223a6e756c6c7d"
+    },
+    {
+      "id": "A6-007",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Boolean literals serialize as the bare tokens 'true'/'false', and sibling keys still sort (RFC8785-3.2.3) regardless of value type.",
+      "input": {
+        "flag_true": true,
+        "flag_false": false
+      },
+      "canonical_utf8_hex": "7b22666c61675f66616c7365223a66616c73652c22666c61675f74727565223a747275657d"
+    },
+    {
+      "id": "A6-008",
+      "group": "a6-arrays-nesting-literals",
+      "clause": "RFC8785-3.2.1",
+      "disposition": "MUST-ACCEPT",
+      "rationale": "Deep alternation of arrays containing objects containing arrays exercises the recursion to more than two levels; order is preserved at every array level and keys sorted at every object level.",
+      "input": {
+        "deep": [
+          {
+            "x": [
+              1,
+              {
+                "y": 2
+              }
+            ]
+          },
+          {
+            "x": []
+          }
+        ]
+      },
+      "canonical_utf8_hex": "7b2264656570223a5b7b2278223a5b312c7b2279223a327d5d7d2c7b2278223a5b5d7d5d7d"
+    }
+  ]
+}
diff --git a/tests/utils/signing_interop_vectors.json b/tests/utils/signing_interop_vectors.json
new file mode 100644
index 000000000..692069109
--- /dev/null
+++ b/tests/utils/signing_interop_vectors.json
@@ -0,0 +1,252 @@
+{
+  "_comment": "Cross-SDK Agent Card signature vectors: the five vectors of the s0-control group of the language-neutral a2a-card-sign-v01 corpus (Layer C of the corpus whose Layers A and B are a2a-tck#228 and #245), keeping only the fields these tests read. Every card carries every REQUIRED field and no field at its default value, so the canonical readings in use today agree on its bytes and these expectations hold however a2aproject/A2A#2122 is settled. The key is a published test key (derivation in `test_key`); it signs test vectors only. The jku in each protected header is a placeholder that is never fetched.",
+  "corpus": "a2a-card-sign-v01",
+  "specRef": "https://a2a-protocol.org/latest/specification/#841-canonicalization-requirements",
+  "oracles": [
+    "rfc8785 (PyPI, 0.1.4)",
+    "gowebpki/jcs (Go, v1.0.1)"
+  ],
+  "test_key": {
+    "kid": "hs-interop-test-v1",
+    "alg": "ES256",
+    "jwk": {
+      "kty": "EC",
+      "crv": "P-256",
+      "x": "khLaGq9LmIvsjFv8YF0N4IJwRGvldb36SwqntLYct04",
+      "y": "XCMP49DgLRfdGJKDr5MacrOCNaDXIwSvoFjID8ORkmQ",
+      "kid": "hs-interop-test-v1",
+      "alg": "ES256",
+      "use": "sig"
+    },
+    "derivation": "d = int.from_bytes(sha256(phrase), 'big') mod (n - 1) + 1 on P-256",
+    "phrase": "HORIZON SHIELD A2A card-signing interop test key v1 (public, test vectors only)",
+    "note": "Published test key, so anyone can re-create the private key and re-sign every reference vector byte for byte (RFC 6979). It signs test vectors only and is nobody's production key."
+  },
+  "counts": {
+    "accept": 4,
+    "reject": 1,
+    "total": 5
+  },
+  "vectors": [
+    {
+      "id": "S0-001",
+      "disposition": "MUST-ACCEPT",
+      "signer": "reference (ES256, RFC 6979)",
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c2264656661756c74496e7075744d6f646573223a5b22746578742f706c61696e225d2c2264656661756c744f75747075744d6f646573223a5b22746578742f706c61696e225d2c226465736372697074696f6e223a2250726f6265206361726420666f722063726f73732d53444b207369676e617475726520636865636b73222c226e616d65223a22496e7465726f702050726f6265222c22736b696c6c73223a5b7b226465736372697074696f6e223a22416e737765727320612070726f6265222c226964223a2270726f6265222c226e616d65223a2250726f6265222c2274616773223a5b2270726f6265225d7d5d2c22737570706f72746564496e7465726661636573223a5b7b2270726f746f636f6c42696e64696e67223a224a534f4e525043222c2270726f746f636f6c56657273696f6e223a22312e30222c2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d5d2c2276657273696f6e223a22312e302e30227d",
+      "served_card": {
+        "name": "Interop Probe",
+        "description": "Probe card for cross-SDK signature checks",
+        "version": "1.0.0",
+        "supportedInterfaces": [
+          {
+            "url": "https://example.com/a2a/v1",
+            "protocolBinding": "JSONRPC",
+            "protocolVersion": "1.0"
+          }
+        ],
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "defaultInputModes": [
+          "text/plain"
+        ],
+        "defaultOutputModes": [
+          "text/plain"
+        ],
+        "skills": [
+          {
+            "id": "probe",
+            "name": "Probe",
+            "description": "Answers a probe",
+            "tags": [
+              "probe"
+            ]
+          }
+        ],
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYTJhLWNhcmQtc2lnbi12MDEvdGVzdGtleV9qd2tzLmpzb24iLCJraWQiOiJocy1pbnRlcm9wLXRlc3QtdjEiLCJ0eXAiOiJKT1NFIn0",
+            "signature": "jkAX98oJc4IUm6400xBQWnk5_dN33PH6KSz3KYVh6mA6gvdaroVnSVxSkzT5NoNLVIN3IoAaxvHK4etXsDMelQ"
+          }
+        ]
+      }
+    },
+    {
+      "id": "S0-002",
+      "disposition": "MUST-ACCEPT",
+      "signer": "a2a-sdk 1.2.1",
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c2264656661756c74496e7075744d6f646573223a5b22746578742f706c61696e225d2c2264656661756c744f75747075744d6f646573223a5b22746578742f706c61696e225d2c226465736372697074696f6e223a2250726f6265206361726420666f722063726f73732d53444b207369676e617475726520636865636b73222c226e616d65223a22496e7465726f702050726f6265222c22736b696c6c73223a5b7b226465736372697074696f6e223a22416e737765727320612070726f6265222c226964223a2270726f6265222c226e616d65223a2250726f6265222c2274616773223a5b2270726f6265225d7d5d2c22737570706f72746564496e7465726661636573223a5b7b2270726f746f636f6c42696e64696e67223a224a534f4e525043222c2270726f746f636f6c56657273696f6e223a22312e30222c2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d5d2c2276657273696f6e223a22312e302e30227d",
+      "served_card": {
+        "name": "Interop Probe",
+        "description": "Probe card for cross-SDK signature checks",
+        "version": "1.0.0",
+        "supportedInterfaces": [
+          {
+            "url": "https://example.com/a2a/v1",
+            "protocolBinding": "JSONRPC",
+            "protocolVersion": "1.0"
+          }
+        ],
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "defaultInputModes": [
+          "text/plain"
+        ],
+        "defaultOutputModes": [
+          "text/plain"
+        ],
+        "skills": [
+          {
+            "id": "probe",
+            "name": "Probe",
+            "description": "Answers a probe",
+            "tags": [
+              "probe"
+            ]
+          }
+        ],
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYTJhLWNhcmQtc2lnbi12MDEvdGVzdGtleV9qd2tzLmpzb24iLCJraWQiOiJocy1pbnRlcm9wLXRlc3QtdjEiLCJ0eXAiOiJKT1NFIn0",
+            "signature": "nw-32J6gLi6LsENaVDE6Qjz1oiagGEGtY6hYEc-LLXD3hmMLSYZ6cIZH7U9YHja3Hkqk-Uh4CUq2EtZY_TnjDg"
+          }
+        ]
+      }
+    },
+    {
+      "id": "S0-003",
+      "disposition": "MUST-ACCEPT",
+      "signer": "@a2a-js/sdk 1.3.0",
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c2264656661756c74496e7075744d6f646573223a5b22746578742f706c61696e225d2c2264656661756c744f75747075744d6f646573223a5b22746578742f706c61696e225d2c226465736372697074696f6e223a2250726f6265206361726420666f722063726f73732d53444b207369676e617475726520636865636b73222c226e616d65223a22496e7465726f702050726f6265222c22736b696c6c73223a5b7b226465736372697074696f6e223a22416e737765727320612070726f6265222c226964223a2270726f6265222c226e616d65223a2250726f6265222c2274616773223a5b2270726f6265225d7d5d2c22737570706f72746564496e7465726661636573223a5b7b2270726f746f636f6c42696e64696e67223a224a534f4e525043222c2270726f746f636f6c56657273696f6e223a22312e30222c2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d5d2c2276657273696f6e223a22312e302e30227d",
+      "served_card": {
+        "name": "Interop Probe",
+        "description": "Probe card for cross-SDK signature checks",
+        "version": "1.0.0",
+        "supportedInterfaces": [
+          {
+            "url": "https://example.com/a2a/v1",
+            "protocolBinding": "JSONRPC",
+            "protocolVersion": "1.0"
+          }
+        ],
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "defaultInputModes": [
+          "text/plain"
+        ],
+        "defaultOutputModes": [
+          "text/plain"
+        ],
+        "skills": [
+          {
+            "id": "probe",
+            "name": "Probe",
+            "description": "Answers a probe",
+            "tags": [
+              "probe"
+            ]
+          }
+        ],
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpPU0UiLCJraWQiOiJocy1pbnRlcm9wLXRlc3QtdjEiLCJqa3UiOiJodHRwczovL2V4YW1wbGUuY29tL2EyYS1jYXJkLXNpZ24tdjAxL3Rlc3RrZXlfandrcy5qc29uIn0",
+            "signature": "aJbacfQKkE_YmVBGBCqwVtLZR9HOIPLlbzhVkF27T6ISnYiSJPeXX9xcVl9EhhRu-bk8P2iRQGtBmMd_eWR1oQ"
+          }
+        ]
+      }
+    },
+    {
+      "id": "S0-004",
+      "disposition": "MUST-ACCEPT",
+      "signer": "a2a-go main 534a60fc",
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c2264656661756c74496e7075744d6f646573223a5b22746578742f706c61696e225d2c2264656661756c744f75747075744d6f646573223a5b22746578742f706c61696e225d2c226465736372697074696f6e223a2250726f6265206361726420666f722063726f73732d53444b207369676e617475726520636865636b73222c226e616d65223a22496e7465726f702050726f6265222c22736b696c6c73223a5b7b226465736372697074696f6e223a22416e737765727320612070726f6265222c226964223a2270726f6265222c226e616d65223a2250726f6265222c2274616773223a5b2270726f6265225d7d5d2c22737570706f72746564496e7465726661636573223a5b7b2270726f746f636f6c42696e64696e67223a224a534f4e525043222c2270726f746f636f6c56657273696f6e223a22312e30222c2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d5d2c2276657273696f6e223a22312e302e30227d",
+      "served_card": {
+        "name": "Interop Probe",
+        "description": "Probe card for cross-SDK signature checks",
+        "version": "1.0.0",
+        "supportedInterfaces": [
+          {
+            "url": "https://example.com/a2a/v1",
+            "protocolBinding": "JSONRPC",
+            "protocolVersion": "1.0"
+          }
+        ],
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "defaultInputModes": [
+          "text/plain"
+        ],
+        "defaultOutputModes": [
+          "text/plain"
+        ],
+        "skills": [
+          {
+            "id": "probe",
+            "name": "Probe",
+            "description": "Answers a probe",
+            "tags": [
+              "probe"
+            ]
+          }
+        ],
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYTJhLWNhcmQtc2lnbi12MDEvdGVzdGtleV9qd2tzLmpzb24iLCJraWQiOiJocy1pbnRlcm9wLXRlc3QtdjEiLCJ0eXAiOiJKT1NFIn0",
+            "signature": "Sm8gkamh8mcy5OsA5q84-GHO_hL5hyGrkyB8k4qJ1gm_4M64eMB6Av_m3sZSVNzgvygKXTTpeWM_wL22COXTww"
+          }
+        ]
+      }
+    },
+    {
+      "id": "S0-REJECT-005",
+      "disposition": "MUST-REJECT",
+      "signer": "reference (ES256, RFC 6979)",
+      "canonical_utf8_hex": "7b226361706162696c6974696573223a7b22707573684e6f74696669636174696f6e73223a66616c73652c2273747265616d696e67223a747275657d2c2264656661756c74496e7075744d6f646573223a5b22746578742f706c61696e225d2c2264656661756c744f75747075744d6f646573223a5b22746578742f706c61696e225d2c226465736372697074696f6e223a2250726f6265206361726420666f722063726f73732d53444b207369676e617475726520636865636b732e222c226e616d65223a22496e7465726f702050726f6265222c22736b696c6c73223a5b7b226465736372697074696f6e223a22416e737765727320612070726f6265222c226964223a2270726f6265222c226e616d65223a2250726f6265222c2274616773223a5b2270726f6265225d7d5d2c22737570706f72746564496e7465726661636573223a5b7b2270726f746f636f6c42696e64696e67223a224a534f4e525043222c2270726f746f636f6c56657273696f6e223a22312e30222c2275726c223a2268747470733a2f2f6578616d706c652e636f6d2f6132612f7631227d5d2c2276657273696f6e223a22312e302e30227d",
+      "served_card": {
+        "name": "Interop Probe",
+        "description": "Probe card for cross-SDK signature checks.",
+        "version": "1.0.0",
+        "supportedInterfaces": [
+          {
+            "url": "https://example.com/a2a/v1",
+            "protocolBinding": "JSONRPC",
+            "protocolVersion": "1.0"
+          }
+        ],
+        "capabilities": {
+          "streaming": true,
+          "pushNotifications": false
+        },
+        "defaultInputModes": [
+          "text/plain"
+        ],
+        "defaultOutputModes": [
+          "text/plain"
+        ],
+        "skills": [
+          {
+            "id": "probe",
+            "name": "Probe",
+            "description": "Answers a probe",
+            "tags": [
+              "probe"
+            ]
+          }
+        ],
+        "signatures": [
+          {
+            "protected": "eyJhbGciOiJFUzI1NiIsImprdSI6Imh0dHBzOi8vZXhhbXBsZS5jb20vYTJhLWNhcmQtc2lnbi12MDEvdGVzdGtleV9qd2tzLmpzb24iLCJraWQiOiJocy1pbnRlcm9wLXRlc3QtdjEiLCJ0eXAiOiJKT1NFIn0",
+            "signature": "jkAX98oJc4IUm6400xBQWnk5_dN33PH6KSz3KYVh6mA6gvdaroVnSVxSkzT5NoNLVIN3IoAaxvHK4etXsDMelQ"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/tests/utils/test_a2a_errors.py b/tests/utils/test_a2a_errors.py
new file mode 100644
index 000000000..ea7133add
--- /dev/null
+++ b/tests/utils/test_a2a_errors.py
@@ -0,0 +1,44 @@
+import pytest
+
+from a2a.utils.errors import (
+    A2AError,
+    InvalidParamsError,
+    TaskNotFoundError,
+    VersionNotSupportedError,
+)
+
+
+class TestA2AErrorRepr:
+    """Test cases for the __repr__ of A2AError and its subclasses."""
+
+    @pytest.mark.parametrize(
+        ('error', 'expected'),
+        [
+            (A2AError(), "A2AError(message='A2A Error', data=None)"),
+            (
+                TaskNotFoundError(),
+                "TaskNotFoundError(message='Task not found', data=None)",
+            ),
+            (
+                TaskNotFoundError('Task abc not found'),
+                "TaskNotFoundError(message='Task abc not found', data=None)",
+            ),
+            (
+                InvalidParamsError('Invalid field', data={'field': 'id'}),
+                "InvalidParamsError(message='Invalid field', data={'field': 'id'})",
+            ),
+            (
+                VersionNotSupportedError(data={'supported': ['1.0']}),
+                "VersionNotSupportedError(message='Version not supported', "
+                "data={'supported': ['1.0']})",
+            ),
+        ],
+    )
+    def test_repr(self, error: A2AError, expected: str) -> None:
+        """Test that repr exposes message and data as keyword arguments."""
+        assert repr(error) == expected
+
+    def test_str_unchanged(self) -> None:
+        """Test that __str__ still returns only the message."""
+        error = InvalidParamsError('Invalid field', data={'field': 'id'})
+        assert str(error) == 'Invalid field'
diff --git a/tests/utils/test_constants.py b/tests/utils/test_constants.py
new file mode 100644
index 000000000..e5243ae17
--- /dev/null
+++ b/tests/utils/test_constants.py
@@ -0,0 +1,40 @@
+"""Tests for a2a.utils.constants module."""
+
+from a2a.server.agent_execution import active_task
+from a2a.server.request_handlers import default_request_handler
+from a2a.utils import constants
+
+
+def test_agent_card_constants():
+    """Test that agent card constants have expected values."""
+    assert (
+        constants.AGENT_CARD_WELL_KNOWN_PATH == '/.well-known/agent-card.json'
+    )
+
+
+def test_default_rpc_url():
+    """Test default RPC URL constant."""
+    assert constants.DEFAULT_RPC_URL == '/'
+
+
+def test_version_header():
+    """Test version header constant."""
+    assert constants.VERSION_HEADER == 'A2A-Version'
+
+
+def test_protocol_versions():
+    """Test protocol version constants."""
+    assert constants.PROTOCOL_VERSION_1_0 == '1.0'
+    assert constants.PROTOCOL_VERSION_CURRENT == '1.0'
+
+
+def test_task_state_sets_keep_their_previous_import_paths():
+    """Test that the previous public names still resolve to the shared sets."""
+    assert active_task.TERMINAL_TASK_STATES is constants.TERMINAL_TASK_STATES
+    assert (
+        active_task.INTERRUPTED_TASK_STATES is constants.INTERRUPTED_TASK_STATES
+    )
+    assert (
+        default_request_handler.TERMINAL_TASK_STATES
+        is constants.TERMINAL_TASK_STATES
+    )
diff --git a/tests/utils/test_error_handlers.py b/tests/utils/test_error_handlers.py
new file mode 100644
index 000000000..3c30b09b7
--- /dev/null
+++ b/tests/utils/test_error_handlers.py
@@ -0,0 +1,250 @@
+"""Tests for a2a.utils.error_handlers module."""
+
+import logging
+
+from unittest.mock import patch
+
+import pytest
+
+from a2a.types import (
+    InternalError,
+)
+from a2a.utils.error_handlers import (
+    build_rest_error_payload,
+    rest_error_handler,
+    rest_stream_error_handler,
+)
+from a2a.utils.errors import (
+    InvalidParamsError,
+    InvalidRequestError,
+)
+
+
+class MockJSONResponse:
+    def __init__(self, content, status_code, media_type=None):
+        self.content = content
+        self.status_code = status_code
+        self.media_type = media_type
+
+
+class MockEventSourceResponse:
+    def __init__(self, body_iterator):
+        self.body_iterator = body_iterator
+
+
+@pytest.mark.asyncio
+async def test_rest_error_handler_server_error():
+    """Test rest_error_handler with A2AError."""
+    error = InvalidRequestError(message='Bad request')
+
+    @rest_error_handler
+    async def failing_func():
+        raise error
+
+    with patch('a2a.utils.error_handlers.JSONResponse', MockJSONResponse):
+        result = await failing_func()
+
+    assert isinstance(result, MockJSONResponse)
+    assert result.status_code == 400
+    assert result.media_type == 'application/json'
+    assert result.content == {
+        'error': {
+            'code': 400,
+            'status': 'INVALID_ARGUMENT',
+            'message': 'Bad request',
+            'details': [
+                {
+                    '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+                    'reason': 'INVALID_REQUEST',
+                    'domain': 'a2a-protocol.org',
+                    'metadata': {},
+                }
+            ],
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_rest_error_handler_unknown_exception():
+    """Test rest_error_handler with unknown exception."""
+
+    @rest_error_handler
+    async def failing_func():
+        raise ValueError('Unexpected error')
+
+    with patch('a2a.utils.error_handlers.JSONResponse', MockJSONResponse):
+        result = await failing_func()
+
+    assert isinstance(result, MockJSONResponse)
+    assert result.status_code == 500
+    assert result.media_type == 'application/json'
+    assert result.content == {
+        'error': {
+            'code': 500,
+            'status': 'INTERNAL',
+            'message': 'unknown exception',
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_rest_stream_error_handler_server_error():
+    """Test rest_stream_error_handler with A2AError."""
+    error = InternalError(message='Internal server error')
+
+    @rest_stream_error_handler
+    async def failing_stream():
+        raise error
+
+    response = await failing_stream()
+
+    assert response.status_code == 500
+
+
+@pytest.mark.asyncio
+async def test_rest_stream_error_handler_reraises_exception():
+    """Test rest_stream_error_handler catches other exceptions and returns JSONResponse."""
+
+    @rest_stream_error_handler
+    async def failing_stream():
+        raise RuntimeError('Stream failed')
+
+    response = await failing_stream()
+    assert response.status_code == 500
+
+
+@pytest.mark.asyncio
+async def test_rest_error_handler_success():
+    """Test rest_error_handler on success."""
+
+    @rest_error_handler
+    async def successful_func():
+        return 'success'
+
+    result = await successful_func()
+    assert result == 'success'
+
+
+@pytest.mark.asyncio
+async def test_rest_stream_error_handler_generator_error(caplog):
+    """Test rest_stream_error_handler catches error during async generation after first success."""
+    error = InternalError(message='Stream error during generation')
+
+    async def failing_generator():
+        yield 'success chunk 1'
+        raise error
+
+    @rest_stream_error_handler
+    async def successful_prep_failing_stream():
+        return MockEventSourceResponse(failing_generator())
+
+    response = await successful_prep_failing_stream()
+
+    # Assert it returns successfully
+    assert isinstance(response, MockEventSourceResponse)
+
+    # Now consume the stream
+    chunks = []
+    with (
+        caplog.at_level(logging.ERROR),
+        pytest.raises(InternalError) as exc_info,
+    ):
+        async for chunk in response.body_iterator:
+            chunks.append(chunk)  # noqa: PERF401
+    assert chunks == ['success chunk 1']
+    assert exc_info.value == error
+
+
+@pytest.mark.asyncio
+async def test_rest_stream_error_handler_generator_unknown_error(caplog):
+    """Test rest_stream_error_handler catches unknown error during async generation."""
+
+    async def failing_generator():
+        yield 'success chunk 1'
+        raise RuntimeError('Unknown stream failure')
+
+    @rest_stream_error_handler
+    async def successful_prep_failing_stream():
+        return MockEventSourceResponse(failing_generator())
+
+    response = await successful_prep_failing_stream()
+
+    chunks = []
+    with (
+        caplog.at_level(logging.ERROR),
+        pytest.raises(RuntimeError, match='Unknown stream failure'),
+    ):
+        async for chunk in response.body_iterator:
+            chunks.append(chunk)  # noqa: PERF401
+    assert chunks == ['success chunk 1']
+    assert 'Unknown streaming error occurred' in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_rest_stream_error_handler_success():
+    """Test rest_stream_error_handler on success."""
+
+    @rest_stream_error_handler
+    async def successful_stream():
+        return 'success_stream'
+
+    result = await successful_stream()
+    assert result == 'success_stream'
+
+
+def test_build_rest_error_payload_invalid_params_includes_bad_request():
+    """REST error payload for InvalidParamsError with validation errors must
+    include both an ErrorInfo and a BadRequest typed-detail entry, matching
+    the gRPC Status.details shape (see a2aproject/A2A#1627)."""
+    error = InvalidParamsError(
+        message='Validation failed',
+        data={
+            'errors': [
+                {'field': 'message.parts', 'message': 'At least one required'},
+                {'field': 'message.role', 'message': 'Unknown role'},
+            ]
+        },
+    )
+
+    payload = build_rest_error_payload(error)
+
+    assert payload['error']['code'] == 400
+    assert payload['error']['status'] == 'INVALID_ARGUMENT'
+    assert payload['error']['message'] == 'Validation failed'
+
+    details = payload['error']['details']
+    assert len(details) == 2
+
+    error_info, bad_request = details
+    assert error_info == {
+        '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+        'reason': 'INVALID_PARAMS',
+        'domain': 'a2a-protocol.org',
+        'metadata': {
+            'errors': [
+                {'field': 'message.parts', 'message': 'At least one required'},
+                {'field': 'message.role', 'message': 'Unknown role'},
+            ]
+        },
+    }
+    assert bad_request == {
+        '@type': 'type.googleapis.com/google.rpc.BadRequest',
+        'fieldViolations': [
+            {
+                'field': 'message.parts',
+                'description': 'At least one required',
+            },
+            {'field': 'message.role', 'description': 'Unknown role'},
+        ],
+    }
+
+
+def test_build_rest_error_payload_invalid_params_no_validation_errors():
+    """InvalidParamsError without ``data['errors']`` must not append a
+    BadRequest entry — only the canonical ErrorInfo."""
+    error = InvalidParamsError(message='Bad params')
+    payload = build_rest_error_payload(error)
+    assert len(payload['error']['details']) == 1
+    assert payload['error']['details'][0]['@type'] == (
+        'type.googleapis.com/google.rpc.ErrorInfo'
+    )
diff --git a/tests/utils/test_grpc_status.py b/tests/utils/test_grpc_status.py
new file mode 100644
index 000000000..e62267963
--- /dev/null
+++ b/tests/utils/test_grpc_status.py
@@ -0,0 +1,143 @@
+import grpc
+import pytest
+
+from a2a.utils.grpc_status import (
+    GRPC_STATUS_DETAILS_BIN_KEY,
+    status_from_call,
+    status_to_grpc,
+)
+from google.protobuf import any_pb2
+from google.rpc import error_details_pb2, status_pb2
+
+
+class MockGrpcCall:
+    """Mock for a gRPC Call object simulating trailing metadata and status info."""
+
+    def __init__(
+        self, code: grpc.StatusCode, details: str, trailing_metadata: tuple
+    ):
+        self._code = code
+        self._details = details
+        self._trailing_metadata = trailing_metadata
+
+    def code(self) -> grpc.StatusCode:
+        return self._code
+
+    def details(self) -> str:
+        return self._details
+
+    def trailing_metadata(self) -> tuple:
+        return self._trailing_metadata
+
+
+def test_status_to_grpc_success():
+    """Test that a Status protobuf is correctly mapped to GrpcStatus namedtuple."""
+    status = status_pb2.Status(
+        code=grpc.StatusCode.INVALID_ARGUMENT.value[0],
+        message='Invalid parameter provided',
+    )
+
+    grpc_status = status_to_grpc(status)
+
+    assert grpc_status.code == grpc.StatusCode.INVALID_ARGUMENT
+    assert grpc_status.details == 'Invalid parameter provided'
+    assert len(grpc_status.trailing_metadata) == 1
+
+    key, val = grpc_status.trailing_metadata[0]
+    assert key == GRPC_STATUS_DETAILS_BIN_KEY
+
+    # Parse back the serialized bytes to verify content
+    parsed_status = status_pb2.Status()
+    parsed_status.ParseFromString(val)
+    assert parsed_status.code == status.code
+    assert parsed_status.message == status.message
+
+
+def test_status_to_grpc_invalid_code():
+    """Test that ValueError is raised for an invalid gRPC status code value."""
+    status = status_pb2.Status(code=999, message='Bad status code')
+    with pytest.raises(ValueError, match='Invalid status code 999'):
+        status_to_grpc(status)
+
+
+def test_status_from_call_no_metadata():
+    """Test that status_from_call returns None if trailing metadata is missing."""
+    call = MockGrpcCall(grpc.StatusCode.OK, 'OK', ())
+    assert status_from_call(call) is None
+
+
+def test_status_from_call_success_roundtrip():
+    """Test standard roundtrip: Status -> status_to_grpc -> Call -> status_from_call."""
+    # 1. Create a status with error details
+    status = status_pb2.Status(
+        code=grpc.StatusCode.NOT_FOUND.value[0],
+        message='Task not found',
+    )
+    error_info = error_details_pb2.ErrorInfo(
+        reason='TASK_NOT_FOUND',
+        domain='a2a-protocol.org',
+    )
+    detail = any_pb2.Any()
+    detail.Pack(error_info)
+    status.details.append(detail)
+
+    # 2. Convert to gRPC components
+    grpc_status = status_to_grpc(status)
+
+    # 3. Wrap in a mock Call object
+    call = MockGrpcCall(
+        code=grpc_status.code,
+        details=grpc_status.details,
+        trailing_metadata=grpc_status.trailing_metadata,
+    )
+
+    # 4. Parse back using status_from_call
+    parsed_status = status_from_call(call)
+
+    assert parsed_status is not None
+    assert parsed_status.code == status.code
+    assert parsed_status.message == status.message
+    assert len(parsed_status.details) == 1
+
+    parsed_detail = error_details_pb2.ErrorInfo()
+    parsed_status.details[0].Unpack(parsed_detail)
+    assert parsed_detail.reason == 'TASK_NOT_FOUND'
+    assert parsed_detail.domain == 'a2a-protocol.org'
+
+
+def test_status_from_call_mismatched_code():
+    """Test that ValueError is raised if call status code doesn't match parsed status code."""
+    status = status_pb2.Status(
+        code=grpc.StatusCode.INVALID_ARGUMENT.value[0],
+        message='Mismatched status code test',
+    )
+    grpc_status = status_to_grpc(status)
+
+    # Intentionally change the mock Call code to StatusCode.UNAUTHENTICATED
+    call = MockGrpcCall(
+        code=grpc.StatusCode.UNAUTHENTICATED,
+        details=grpc_status.details,
+        trailing_metadata=grpc_status.trailing_metadata,
+    )
+
+    with pytest.raises(ValueError, match='Mismatched status code'):
+        status_from_call(call)
+
+
+def test_status_from_call_mismatched_message():
+    """Test that ValueError is raised if call details message doesn't match parsed status message."""
+    status = status_pb2.Status(
+        code=grpc.StatusCode.INVALID_ARGUMENT.value[0],
+        message='Mismatched status message test',
+    )
+    grpc_status = status_to_grpc(status)
+
+    # Intentionally change the mock Call details message
+    call = MockGrpcCall(
+        code=grpc_status.code,
+        details='A completely different message',
+        trailing_metadata=grpc_status.trailing_metadata,
+    )
+
+    with pytest.raises(ValueError, match='Mismatched status message'):
+        status_from_call(call)
diff --git a/tests/utils/test_input_mode_validator.py b/tests/utils/test_input_mode_validator.py
new file mode 100644
index 000000000..86a302453
--- /dev/null
+++ b/tests/utils/test_input_mode_validator.py
@@ -0,0 +1,151 @@
+"""Tests for media-type validation against an agent card's declared input modes."""
+
+import pytest
+
+from a2a.types.a2a_pb2 import AgentCard, AgentSkill, Message, Part, Role
+from a2a.utils.errors import ContentTypeNotSupportedError
+from a2a.utils.input_mode_validator import validate_input_modes
+
+
+def make_card(
+    *input_modes: str, skill_modes: list[str] | None = None
+) -> AgentCard:
+    skills = (
+        [AgentSkill(id='s1', name='skill', input_modes=skill_modes)]
+        if skill_modes is not None
+        else []
+    )
+    return AgentCard(
+        name='test_agent',
+        version='1.0',
+        default_input_modes=list(input_modes),
+        skills=skills,
+    )
+
+
+def make_message(*parts: Part) -> Message:
+    return Message(role=Role.ROLE_USER, message_id='msg-1', parts=list(parts))
+
+
+def test_declared_media_type_is_accepted():
+    validate_input_modes(
+        make_message(Part(text='hi', media_type='text/plain')),
+        make_card('text/plain'),
+    )
+
+
+def test_undeclared_media_type_is_rejected():
+    with pytest.raises(ContentTypeNotSupportedError) as exc_info:
+        validate_input_modes(
+            make_message(Part(text='hi', media_type='application/x-nope')),
+            make_card('text/plain'),
+        )
+
+    assert 'application/x-nope' in exc_info.value.message
+
+
+def test_absent_media_type_is_not_checked():
+    """A proto3 string defaults to '', which states nothing to contradict."""
+    validate_input_modes(make_message(Part(text='hi')), make_card('image/png'))
+
+
+def test_card_declaring_no_input_modes_accepts_anything():
+    validate_input_modes(
+        make_message(Part(text='hi', media_type='application/x-nope')),
+        make_card(),
+    )
+
+
+def test_every_part_is_checked_not_just_the_first():
+    with pytest.raises(ContentTypeNotSupportedError):
+        validate_input_modes(
+            make_message(
+                Part(text='ok', media_type='text/plain'),
+                Part(text='bad', media_type='application/x-nope'),
+            ),
+            make_card('text/plain'),
+        )
+
+
+def test_any_declared_mode_may_match():
+    validate_input_modes(
+        make_message(Part(text='hi', media_type='image/png')),
+        make_card('text/plain', 'image/png'),
+    )
+
+
+def test_a_skill_may_widen_beyond_the_card_default():
+    """AgentSkill.input_modes overrides the default, so it can add modes."""
+    validate_input_modes(
+        make_message(Part(text='hi', media_type='image/png')),
+        make_card('text/plain', skill_modes=['image/png']),
+    )
+
+
+def test_a_mode_no_skill_declares_is_still_rejected():
+    with pytest.raises(ContentTypeNotSupportedError) as exc_info:
+        validate_input_modes(
+            make_message(Part(text='hi', media_type='application/x-nope')),
+            make_card('text/plain', skill_modes=['image/png']),
+        )
+
+    assert 'text/plain' in exc_info.value.message
+    assert 'image/png' in exc_info.value.message
+
+
+def test_a_skill_narrowing_its_modes_does_not_narrow_the_union():
+    """The request does not name a skill, so the card default stays allowed.
+
+    Whether this particular skill would accept text/plain is a question only
+    that skill can answer; the SDK cannot route the message to find out.
+    """
+    validate_input_modes(
+        make_message(Part(text='hi', media_type='text/plain')),
+        make_card('text/plain', skill_modes=['image/png']),
+    )
+
+
+def test_skills_declaring_nothing_leave_the_card_default_in_force():
+    with pytest.raises(ContentTypeNotSupportedError):
+        validate_input_modes(
+            make_message(Part(text='hi', media_type='application/x-nope')),
+            make_card('text/plain', skill_modes=[]),
+        )
+
+
+def test_skill_modes_alone_are_enforced_when_the_card_declares_none():
+    with pytest.raises(ContentTypeNotSupportedError):
+        validate_input_modes(
+            make_message(Part(text='hi', media_type='application/x-nope')),
+            make_card(skill_modes=['image/png']),
+        )
+
+
+@pytest.mark.parametrize(
+    ('part_type', 'card_type'),
+    [
+        ('Text/Plain', 'text/plain'),
+        ('text/plain', 'TEXT/PLAIN'),
+        ('text/plain; charset=utf-8', 'text/plain'),
+        ('text/plain', 'text/plain;charset=utf-8'),
+        (' application/json ', 'application/json'),
+    ],
+)
+def test_media_types_match_on_type_and_subtype(part_type, card_type):
+    """RFC 2045 5.1: type and subtype are case-insensitive, parameters are not the type."""
+    validate_input_modes(
+        make_message(Part(text='hi', media_type=part_type)),
+        make_card(card_type),
+    )
+
+
+def test_parameters_do_not_widen_the_declared_type():
+    with pytest.raises(ContentTypeNotSupportedError) as exc_info:
+        validate_input_modes(
+            make_message(
+                Part(text='hi', media_type='text/html; charset=utf-8')
+            ),
+            make_card('text/plain'),
+        )
+
+    assert 'text/html; charset=utf-8' in exc_info.value.message
diff --git a/tests/utils/test_jcs.py b/tests/utils/test_jcs.py
new file mode 100644
index 000000000..78992c393
--- /dev/null
+++ b/tests/utils/test_jcs.py
@@ -0,0 +1,599 @@
+"""RFC 8785 (JCS) conformance tests for Agent Card canonicalization.
+
+The vector corpus in `jcs_vectors.json` is language-neutral and was produced by
+two independent RFC 8785 implementations written by neither SDK author, so
+these tests check conformance against the RFC rather than against this SDK's
+own output.
+"""
+
+import base64
+import hashlib
+import json
+import math
+import random
+import struct
+
+from pathlib import Path
+from typing import Any
+
+import jwt
+import pytest
+import rfc8785
+
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentExtension,
+    AgentInterface,
+    AgentSkill,
+)
+from a2a.utils import signing
+from a2a.utils._jcs import MAX_DEPTH, CanonicalizationError, canonicalize
+from google.protobuf import struct_pb2
+
+
+_VECTORS = json.loads(
+    (Path(__file__).parent / 'jcs_vectors.json').read_text(encoding='utf-8')
+)
+_ACCEPT = [v for v in _VECTORS['vectors'] if v['disposition'] == 'MUST-ACCEPT']
+_REJECT = [v for v in _VECTORS['vectors'] if v['disposition'] == 'MUST-REJECT']
+
+
+def _agent_card(
+    name: str = 'Agent',
+    description: str = 'description',
+    ext_params: dict[str, Any] | None = None,
+) -> AgentCard:
+    """Builds a minimal valid AgentCard, optionally with extension params."""
+    capabilities = AgentCapabilities(streaming=True)
+    if ext_params is not None:
+        params = struct_pb2.Struct()
+        params.update(ext_params)
+        capabilities.extensions.append(
+            AgentExtension(uri='https://example.com/ext', params=params)
+        )
+    return AgentCard(
+        name=name,
+        description=description,
+        version='1.0.0',
+        supported_interfaces=[
+            AgentInterface(
+                url='https://example.com/a2a/v1',
+                protocol_binding='JSONRPC',
+                protocol_version='1.0',
+            )
+        ],
+        capabilities=capabilities,
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        skills=[
+            AgentSkill(
+                id='skill', name='skill', description='skill', tags=['tag']
+            )
+        ],
+    )
+
+
+def test_vector_corpus_is_complete():
+    """The corpus must be whole; a partially loaded corpus passes vacuously."""
+    assert len(_ACCEPT) == _VECTORS['counts']['accept'] == 47
+    assert len(_REJECT) == _VECTORS['counts']['reject'] == 10
+    assert len(_VECTORS['vectors']) == _VECTORS['counts']['total'] == 57
+
+
+@pytest.mark.parametrize('vector', _ACCEPT, ids=lambda v: v['id'])
+def test_vector_must_accept(vector):
+    """Canonical output must match the corpus byte for byte."""
+    value = vector['input']
+    if vector['group'] == 'a2-signatures-exclusion':
+        # Spec 8.4.1 rule 3: the signatures key is excluded unconditionally.
+        # This mirrors the two steps _canonicalize_agent_card applies to the
+        # card dict before serializing it.
+        value = dict(value)
+        value.pop('signatures', None)
+        value = signing._clean_empty(value)
+
+    actual = canonicalize(value).encode('utf-8')
+    assert actual.hex() == vector['canonical_utf8_hex'], vector['rationale']
+
+
+@pytest.mark.parametrize('vector', _REJECT, ids=lambda v: v['id'])
+def test_vector_must_reject(vector):
+    """Values with no canonical form must be refused, not silently mangled."""
+    if vector['group'] == 'a2-signatures-exclusion':
+        # These two vectors reject claimed-canonical output that still carries
+        # a signatures key, which is a property of the producer rather than an
+        # input it can be handed. The producer side is asserted directly.
+        card = _agent_card()
+        card.signatures.append(
+            signing.AgentCardSignature(protected='abc', signature='def')
+        )
+        assert 'signatures' not in json.loads(
+            signing._canonicalize_agent_card(card)
+        )
+        return
+
+    value = json.loads(vector['input_raw'])
+    with pytest.raises(CanonicalizationError):
+        canonicalize(value)
+
+
+@pytest.mark.parametrize('vector', _ACCEPT, ids=lambda v: v['id'])
+def test_vector_agrees_with_independent_implementation(vector):
+    """An independent RFC 8785 implementation must produce the same bytes.
+
+    The corpus and the oracle are separate sources of truth: the corpus could
+    be transcribed wrongly, and the oracle could be wrong about a clause the
+    corpus covers. Requiring both makes a single mistake visible.
+    """
+    value = vector['input']
+    if vector['group'] == 'a2-signatures-exclusion':
+        value = dict(value)
+        value.pop('signatures', None)
+        value = signing._clean_empty(value)
+    assert canonicalize(value).encode('utf-8') == rfc8785.dumps(value)
+
+
+# --- Axis 1: literal UTF-8 rather than \uXXXX escapes (RFC 8785 3.2.2.2) ---
+
+
+def test_non_ascii_is_emitted_as_literal_utf8():
+    """json.dumps defaults to ensure_ascii=True; RFC 8785 forbids the escape."""
+    canonical = signing._canonicalize_agent_card(
+        _agent_card(name='Café Agent', description='Planifie des itinéraires.')
+    )
+    assert 'Café Agent' in canonical
+    assert '\\u00e9' not in canonical
+
+
+def test_line_and_paragraph_separators_are_not_escaped():
+    """U+2028 and U+2029 are escaped in JavaScript source, not in JCS."""
+    canonical = signing._canonicalize_agent_card(_agent_card(name='a
b
c'))
+    assert 'a
b
c' in canonical
+    assert '\\u2028' not in canonical
+    assert '\\u2029' not in canonical
+
+
+def test_mandatory_escapes_are_still_applied():
+    """The C0 range, quote and backslash stay escaped (RFC 8785 3.2.2.2)."""
+    assert canonicalize({'k': 'a"b\\c\nd\te\x00f\x1ff'}) == (
+        '{"k":"a\\"b\\\\c\\nd\\te\\u0000f\\u001ff"}'
+    )
+
+
+def test_non_bmp_characters_survive_as_literal_utf8():
+    """Astral characters are one UTF-8 sequence, not two escaped surrogates."""
+    canonical = canonicalize({'k': '\U0001f600'})
+    assert canonical == '{"k":"\U0001f600"}'
+    assert canonical.encode('utf-8') == b'{"k":"\xf0\x9f\x98\x80"}'
+
+
+# --- Axis 2: UTF-16 code unit key ordering (RFC 8785 3.2.3) ---
+
+
+def test_keys_sort_by_utf16_code_unit_not_code_point():
+    """The two orders disagree whenever a non-BMP key meets a key >= U+E000.
+
+    U+1F600's leading surrogate is 0xD83D, which sorts below U+FF01, while its
+    code point U+1F600 sorts above it. sort_keys=True gets this backwards.
+    """
+    canonical = canonicalize({'\U0001f600': 1, '！': 2})
+    assert canonical == '{"\U0001f600":1,"！":2}'
+    assert json.dumps(
+        {'\U0001f600': 1, '！': 2}, sort_keys=True, ensure_ascii=False
+    ) != canonical.replace(':', ': ').replace(',', ', ')
+    # The decisive assertion: our first key is the astral one.
+    assert list(json.loads(canonical))[0] == '\U0001f600'
+
+
+def test_key_ordering_reaches_the_canonicalizer_through_extension_params():
+    """Arbitrary keys are attacker-reachable via AgentExtension.params."""
+    canonical = signing._canonicalize_agent_card(
+        _agent_card(ext_params={'\U0001f600': 1, '！': 2})
+    )
+    params = canonical[canonical.index('"params"') :]
+    assert params.index('\U0001f600') < params.index('！')
+
+
+def test_keys_sort_by_code_unit_across_the_bmp_boundary():
+    """A shorter key that is a prefix of a longer one sorts first."""
+    assert canonicalize({'ab': 1, 'a': 2, 'b': 3}) == '{"a":2,"ab":1,"b":3}'
+
+
+def test_empty_key_sorts_first():
+    assert canonicalize({'a': 1, '': 2}) == '{"":2,"a":1}'
+
+
+# --- Axis 3: ECMAScript number formatting (RFC 8785 3.2.2.3) ---
+
+
+@pytest.mark.parametrize(
+    ('value', 'expected'),
+    [
+        (0.000001, '0.000001'),
+        (1e-7, '1e-7'),
+        (1e-6, '0.000001'),
+        (0.0, '0'),
+        (-0.0, '0'),
+        (1.0, '1'),
+        (-1.0, '-1'),
+        (1e20, '100000000000000000000'),
+        (1e21, '1e+21'),
+        (1.2e21, '1.2e+21'),
+        (5e-324, '5e-324'),
+        (2.2250738585072014e-308, '2.2250738585072014e-308'),
+        (9007199254740991.0, '9007199254740991'),
+        (0.1, '0.1'),
+        (1.5, '1.5'),
+        (1e100, '1e+100'),
+    ],
+)
+def test_number_formatting(value, expected):
+    """repr and Number::toString disagree on all of these."""
+    assert canonicalize({'n': value}) == f'{{"n":{expected}}}'
+
+
+def test_number_formatting_matches_the_oracle_over_random_doubles():
+    """Sweep the double bit space, not just the cases someone thought of.
+
+    ECMAScript number formatting is the expensive half of RFC 8785 and the
+    half a hand-written table cannot cover: the divergences live at the
+    exponential-notation thresholds, in the denormal range and wherever the
+    shortest round-tripping representation changes length. The seed is fixed
+    so any failure names one reproducible double.
+    """
+    rng = random.Random(8785)
+    compared = 0
+    for _ in range(20000):
+        (value,) = struct.unpack('<d', struct.pack('<Q', rng.getrandbits(64)))
+        if not math.isfinite(value):
+            continue
+        compared += 1
+        assert canonicalize([value]) == rfc8785.dumps([value]).decode(), value
+    # A sweep that silently compared nothing would pass; assert it ran.
+    assert compared > 15000
+
+
+def test_number_formatting_matches_the_oracle_at_the_exponent_thresholds():
+    """The 1e21 and 1e-7 thresholds are where repr and Number::toString part."""
+    values = []
+    for exponent in range(-330, 309):
+        for mantissa in (
+            '1',
+            '1.5',
+            '9',
+            '9.999999999999998',
+            '1.0000000000000002',
+            '5',
+            '3',
+        ):
+            value = float(f'{mantissa}e{exponent}')
+            if math.isfinite(value):
+                values.append(value)
+    assert len(values) > 4000
+    for value in values:
+        assert canonicalize([value]) == rfc8785.dumps([value]).decode(), value
+
+
+def test_number_formatting_matches_independent_implementation():
+    """Cross-check every number case against the oracle, not just our table."""
+    values = [
+        0.000001, 1e-7, 1e-6, 0.0, -0.0, 1.0, -1.0, 1e20, 1e21, 1.2e21,
+        5e-324, 2.2250738585072014e-308, 9007199254740991.0, 0.1, 1.5, 1e100,
+        -1e-7, 3.141592653589793, 1e-323, 1.7976931348623157e308,
+    ]  # fmt: skip
+    for value in values:
+        assert (
+            canonicalize({'n': value}) == rfc8785.dumps({'n': value}).decode()
+        )
+
+
+def test_integral_doubles_lose_their_trailing_zero():
+    """protobuf Struct stores every number as a double, so this is the common case.
+
+    A card declaring an integer extension param currently signs "1.0"; RFC 8785
+    requires "1", which is what every other implementation produces.
+    """
+    canonical = signing._canonicalize_agent_card(
+        _agent_card(ext_params={'count': 1})
+    )
+    assert '"count":1}' in canonical
+    # Anchored on the key: "1.0" also occurs inside the version string.
+    assert '"count":1.0' not in canonical
+
+
+def test_booleans_are_not_treated_as_integers():
+    """bool subclasses int, so an unguarded isinstance check emits 1 and 0."""
+    assert canonicalize({'a': True, 'b': False}) == '{"a":true,"b":false}'
+
+
+@pytest.mark.parametrize('value', [float('nan'), float('inf'), float('-inf')])
+def test_non_finite_numbers_are_rejected(value):
+    with pytest.raises(CanonicalizationError):
+        canonicalize({'n': value})
+
+
+@pytest.mark.parametrize('value', [2**53, -(2**53), 2**63, 10**30])
+def test_integers_outside_the_double_range_are_rejected(value):
+    """Beyond 2**53-1 an integer has no exact JSON number, so no canonical form."""
+    with pytest.raises(CanonicalizationError):
+        canonicalize({'n': value})
+
+
+@pytest.mark.parametrize('value', [2**53 - 1, -(2**53) + 1, 0, -1, 42])
+def test_integers_inside_the_double_range_are_accepted(value):
+    assert canonicalize({'n': value}) == f'{{"n":{value}}}'
+
+
+# --- Depth bound ---
+
+
+def _nest(depth: int) -> dict[str, Any]:
+    value: Any = {'x': 1}
+    for _ in range(depth):
+        value = {'a': value}
+    return value
+
+
+def test_nesting_at_the_limit_is_accepted():
+    """Sit on the boundary, not near it.
+
+    _nest(n) builds n wrappers around a leaf object, so the deepest container
+    is at depth n + 1. MAX_DEPTH - 1 wrappers is therefore the last accepted
+    shape and MAX_DEPTH wrappers is the first rejected one; asserting both
+    pins the limit rather than merely staying below it.
+    """
+    canonicalize(_nest(MAX_DEPTH - 1))
+    with pytest.raises(CanonicalizationError):
+        canonicalize(_nest(MAX_DEPTH))
+
+
+@pytest.mark.parametrize('depth', [MAX_DEPTH + 1, 5000])
+def test_nesting_beyond_the_limit_is_rejected(depth):
+    """Unbounded recursion here is a crash in whoever verifies the card."""
+    with pytest.raises(CanonicalizationError):
+        canonicalize(_nest(depth))
+
+
+@pytest.mark.parametrize('depth', [MAX_DEPTH + 1, 5000])
+def test_clean_empty_is_bounded_too(depth):
+    """_clean_empty runs first, so an uncapped one makes the cap unreachable."""
+    with pytest.raises(CanonicalizationError):
+        signing._clean_empty(_nest(depth))
+
+
+def test_deep_arrays_are_bounded():
+    value: Any = [1]
+    for _ in range(5000):
+        value = [value]
+    with pytest.raises(CanonicalizationError):
+        canonicalize(value)
+
+
+# --- Nesting bound: the jcs_depth_v1 corpus -------------------------------
+
+# `jcs_depth_vectors.json` is the `jcs_depth_v1` corpus. It pins the input a
+# canonicalizer must REFUSE rather than the bytes it must produce, because RFC
+# 8785 states no nesting limit and canonicalization runs before signature
+# verification. Depth counts open containers, the outermost at depth 1, and an
+# empty container is its own level.
+_DEPTH_VECTORS = json.loads(
+    (Path(__file__).parent / 'jcs_depth_vectors.json').read_text(
+        encoding='utf-8'
+    )
+)
+_DEPTH_ACCEPT = [
+    v for v in _DEPTH_VECTORS['vectors'] if v['outcome'] == 'accept'
+]
+_DEPTH_REJECT = [
+    v for v in _DEPTH_VECTORS['vectors'] if v['outcome'] == 'reject'
+]
+
+_DEPTH_OPENERS = {'object': '{"a":', 'array': '['}
+_DEPTH_CLOSERS = {'object': '}', 'array': ']'}
+
+
+def _materialise_depth(rule: dict[str, Any]) -> str:
+    """Materialises a preimage rule into the JSON text it describes."""
+    containers = rule['containers']
+    opened = ''.join(
+        _DEPTH_OPENERS[containers[i % len(containers)]]
+        for i in range(rule['count'])
+    )
+    closed = ''.join(
+        _DEPTH_CLOSERS[containers[i % len(containers)]]
+        for i in range(rule['count'] - 1, -1, -1)
+    )
+    return opened + rule['leaf'] + closed
+
+
+def _empty_leaf_nest(depth: int) -> dict[str, Any]:
+    """Wraps `{}` in `depth` objects: the shape an empty container sits in."""
+    value: Any = {}
+    for _ in range(depth):
+        value = {'a': value}
+    return value
+
+
+@pytest.mark.parametrize(
+    'vector', _DEPTH_VECTORS['vectors'], ids=lambda v: v['vector_id']
+)
+def test_depth_vector_preimage_is_the_pinned_one(vector):
+    """The input is checked before the output: a vector built wrong proves nothing."""
+    encoded = _materialise_depth(vector['preimage_rule']).encode('utf-8')
+    assert len(encoded) == vector['preimage_bytes']
+    assert hashlib.sha256(encoded).hexdigest() == vector['preimage_sha256']
+
+
+@pytest.mark.parametrize('vector', _DEPTH_ACCEPT, ids=lambda v: v['vector_id'])
+def test_depth_at_the_bound_is_canonicalised(vector):
+    """The deepest input the limit admits, the empty-container leaf included."""
+    canonical = canonicalize(
+        json.loads(_materialise_depth(vector['preimage_rule']))
+    )
+    encoded = canonical.encode('utf-8')
+    assert encoded == base64.b64decode(vector['expected_jcs_bytes_b64'])
+    assert hashlib.sha256(encoded).hexdigest() == vector['expected_sha256']
+
+
+@pytest.mark.parametrize('vector', _DEPTH_REJECT, ids=lambda v: v['vector_id'])
+def test_depth_past_the_bound_is_refused(vector):
+    """One container past the limit is refused whatever the innermost value is.
+
+    The refusal is `CanonicalizationError` for every reject vector: the deepest
+    payload here (jcs-depth-104) is far past the bound but still shallow enough
+    for the JSON decoder to accept it, so the bound - not a decoder limit and
+    not a stack exhaustion - is what the caller sees.
+    """
+    with pytest.raises(CanonicalizationError):
+        canonicalize(json.loads(_materialise_depth(vector['preimage_rule'])))
+
+
+def test_an_empty_container_leaf_is_its_own_level():
+    """The case a per-child counter misses.
+
+    A counter that charges a level on recursion into a child never charges an
+    empty container, so it accepts one container too many here while still
+    refusing the same depth wrapped around a scalar.
+    """
+    at_bound = _empty_leaf_nest(MAX_DEPTH - 1)
+    assert canonicalize(at_bound) == (
+        '{"a":' * (MAX_DEPTH - 1) + '{}' + '}' * (MAX_DEPTH - 1)
+    )
+    with pytest.raises(CanonicalizationError):
+        canonicalize(_empty_leaf_nest(MAX_DEPTH))
+
+
+def test_clean_empty_counts_containers_too():
+    """`_clean_empty` runs first, so it has to hold the same bound."""
+    signing._clean_empty(_empty_leaf_nest(MAX_DEPTH - 1))
+    with pytest.raises(CanonicalizationError):
+        signing._clean_empty(_empty_leaf_nest(MAX_DEPTH))
+
+
+# --- Types with no canonical form ---
+
+
+@pytest.mark.parametrize(
+    'value',
+    ['\ud800', 'a\udc00b', '\ud800\ud800'],
+)
+def test_unpaired_surrogates_in_values_are_rejected(value):
+    with pytest.raises(CanonicalizationError):
+        canonicalize({'k': value})
+
+
+@pytest.mark.parametrize('key', ['\ud800', 'b\udc00key'])
+def test_unpaired_surrogates_in_keys_are_rejected(key):
+    with pytest.raises(CanonicalizationError):
+        canonicalize({key: 1})
+
+
+def test_non_string_keys_are_rejected():
+    with pytest.raises(CanonicalizationError):
+        canonicalize({1: 'a'})
+
+
+def test_unsupported_types_are_rejected():
+    with pytest.raises(CanonicalizationError):
+        canonicalize({'k': {1, 2}})
+
+
+def test_noncharacters_are_permitted():
+    """U+FFFE and U+FFFF are valid Unicode; JCS has no rule excluding them."""
+    assert canonicalize({'k': '￾￿'}) == '{"k":"￾￿"}'
+
+
+# --- End to end through the signing API ---
+
+
+def test_signer_and_verifier_agree_on_a_non_ascii_card():
+    """The bytes signed must be the canonical bytes, not a re-serialization.
+
+    Handing a parsed dict to the JWT layer lets PyJWT re-encode it with
+    ensure_ascii=True, which passes for an ASCII card and fails for every other
+    card. The ASCII case is the control.
+    """
+    key = 'a-shared-secret-of-sufficient-length-for-hs256'
+    signer = signing.create_agent_card_signer(key, {'kid': 'k', 'alg': 'HS256'})
+    verifier = signing.create_signature_verifier(
+        lambda kid, jku: key, ['HS256']
+    )
+    for name in ('Agent', 'Café Agent', '🤖 Agent', 'a
b'):
+        verifier(signer(_agent_card(name=name)))
+
+
+def test_canonical_form_matches_the_reference_for_a_non_ascii_card():
+    canonical = signing._canonicalize_agent_card(
+        _agent_card(name='Café Agent', description='Planifie des itinéraires.')
+    )
+    assert canonical.encode('utf-8') == rfc8785.dumps(json.loads(canonical))
+
+
+def test_uncanonicalizable_card_fails_as_a_signature_error():
+    """A hostile card must not raise a new exception type at callers."""
+    key = 'a-shared-secret-of-sufficient-length-for-hs256'
+    card = _agent_card()
+    card.signatures.append(
+        signing.AgentCardSignature(protected='abc', signature='def')
+    )
+    verifier = signing.create_signature_verifier(
+        lambda kid, jku: key, ['HS256']
+    )
+    deep: Any = {'x': 1}
+    for _ in range(MAX_DEPTH + 5):
+        deep = {'a': deep}
+    params = struct_pb2.Struct()
+    # Built directly rather than through the proto parser, whose own recursion
+    # limit is lower than MAX_DEPTH and would refuse this first.
+    _fill_struct(params, deep)
+    card.capabilities.extensions.append(
+        AgentExtension(uri='https://example.com/ext')
+    )
+    card.capabilities.extensions[0].params.CopyFrom(params)
+    with pytest.raises(signing.InvalidSignaturesError):
+        verifier(card)
+
+
+def _fill_struct(struct: struct_pb2.Struct, value: dict[str, Any]) -> None:
+    """Builds a nested Struct without going through the proto parser."""
+    for key, item in value.items():
+        if isinstance(item, dict):
+            _fill_struct(struct.fields[key].struct_value, item)
+        else:
+            struct.fields[key].number_value = item
+
+
+def test_protected_header_is_unchanged_by_the_detached_payload_encoding():
+    """Signing the canonical bytes must not disturb the protected header.
+
+    The signer hands pre-serialized bytes to the JWS layer so that PyJWT
+    cannot re-serialize the payload with ensure_ascii=True. That swap would be
+    a silent compatibility break if it also changed the header, since the
+    header is what a verifier reads kid and alg out of.
+    """
+    key = 'a-shared-secret-of-sufficient-length-for-hs256'
+    header = {'kid': 'k', 'alg': 'HS256'}
+    signed = signing.create_agent_card_signer(key, header)(_agent_card())
+    reference = jwt.encode(
+        payload={'a': 1}, key=key, algorithm='HS256', headers=dict(header)
+    ).split('.')[0]
+    assert signed.signatures[0].protected == reference
+
+
+def test_non_finite_numbers_cannot_reach_the_canonicalizer_through_a_card():
+    """protobuf refuses NaN in a Struct, so the guard in _format_number is depth.
+
+    Recording where the first refusal happens keeps a later protobuf change
+    from quietly moving the only rejection of NaN out of the stack.
+    """
+    params = struct_pb2.Struct()
+    params.fields['x'].number_value = float('nan')
+    card = _agent_card()
+    card.capabilities.extensions.append(
+        AgentExtension(uri='https://example.com/ext')
+    )
+    card.capabilities.extensions[0].params.CopyFrom(params)
+    with pytest.raises(Exception) as excinfo:
+        signing._canonicalize_agent_card(card)
+    assert 'NaN' in str(excinfo.value)
diff --git a/tests/utils/test_json_utils.py b/tests/utils/test_json_utils.py
new file mode 100644
index 000000000..f4adb4376
--- /dev/null
+++ b/tests/utils/test_json_utils.py
@@ -0,0 +1,24 @@
+"""Tests for a2a.utils.json_utils module."""
+
+import json
+
+from a2a.utils import json_utils
+
+
+def test_dumps_emits_raw_utf8_for_non_ascii() -> None:
+    """Non-ASCII characters must serialize as raw UTF-8, not \\uXXXX escapes."""
+    out = json_utils.dumps({'text': '你好'})
+    assert '你好' in out
+    assert '\\u4f60\\u597d' not in out
+
+
+def test_dumps_emits_emoji_as_raw_utf8() -> None:
+    """Emoji (outside the BMP) must also pass through unescaped."""
+    out = json_utils.dumps({'emoji': '🎉'})
+    assert '🎉' in out
+
+
+def test_dumps_round_trips_through_json_loads() -> None:
+    """Wrapper output must remain a valid JSON document."""
+    payload = {'msg': '你好', 'list': ['a', 'é', '日本語'], 'n': 1}
+    assert json.loads(json_utils.dumps(payload)) == payload
diff --git a/tests/utils/test_proto_utils.py b/tests/utils/test_proto_utils.py
new file mode 100644
index 000000000..985dfc78e
--- /dev/null
+++ b/tests/utils/test_proto_utils.py
@@ -0,0 +1,501 @@
+"""Tests for a2a.utils.proto_utils module.
+
+This module tests the proto utilities including to_stream_response and dictionary normalization.
+"""
+
+import logging
+
+from typing import Any, cast
+
+import httpx
+import pytest
+
+from a2a.types.a2a_pb2 import (
+    AgentSkill,
+    ListTasksRequest,
+    Message,
+    Part,
+    Role,
+    StreamResponse,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+)
+from a2a.utils import proto_utils
+from a2a.utils.errors import InvalidParamsError
+from google.protobuf.descriptor import FieldDescriptor
+from google.protobuf.json_format import MessageToDict, Parse, ParseError
+from google.protobuf.message import Message as ProtobufMessage
+from google.protobuf.timestamp_pb2 import Timestamp
+from starlette.datastructures import QueryParams
+
+
+class TestToStreamResponse:
+    """Tests for to_stream_response function."""
+
+    def test_stream_response_with_task(self):
+        """Test to_stream_response with a Task event."""
+        task = Task(
+            id='task-1',
+            context_id='ctx-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+        result = proto_utils.to_stream_response(task)
+
+        assert isinstance(result, StreamResponse)
+        assert result.HasField('task')
+        assert result.task.id == 'task-1'
+
+    def test_stream_response_with_message(self):
+        """Test to_stream_response with a Message event."""
+        message = Message(
+            message_id='msg-1',
+            role=Role.ROLE_AGENT,
+            parts=[Part(text='Hello')],
+        )
+        result = proto_utils.to_stream_response(message)
+
+        assert isinstance(result, StreamResponse)
+        assert result.HasField('message')
+        assert result.message.message_id == 'msg-1'
+
+    def test_stream_response_with_status_update(self):
+        """Test to_stream_response with a TaskStatusUpdateEvent."""
+        status_update = TaskStatusUpdateEvent(
+            task_id='task-1',
+            context_id='ctx-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+        )
+        result = proto_utils.to_stream_response(status_update)
+
+        assert isinstance(result, StreamResponse)
+        assert result.HasField('status_update')
+        assert result.status_update.task_id == 'task-1'
+
+    def test_stream_response_with_artifact_update(self):
+        """Test to_stream_response with a TaskArtifactUpdateEvent."""
+        artifact_update = TaskArtifactUpdateEvent(
+            task_id='task-1',
+            context_id='ctx-1',
+        )
+        result = proto_utils.to_stream_response(artifact_update)
+
+        assert isinstance(result, StreamResponse)
+        assert result.HasField('artifact_update')
+        assert result.artifact_update.task_id == 'task-1'
+
+
+class TestDictSerialization:
+    """Tests for serialization utility functions."""
+
+    def test_make_dict_serializable(self):
+        """Test the make_dict_serializable utility function."""
+
+        class CustomObject:
+            def __str__(self):
+                return 'custom_str'
+
+        test_data = {
+            'string': 'hello',
+            'int': 42,
+            'float': 3.14,
+            'bool': True,
+            'none': None,
+            'custom': CustomObject(),
+            'list': [1, 'two', CustomObject()],
+            'tuple': (1, 2, CustomObject()),
+            'nested': {'inner_custom': CustomObject(), 'inner_normal': 'value'},
+        }
+
+        result = proto_utils.make_dict_serializable(test_data)
+
+        assert result['string'] == 'hello'
+        assert result['int'] == 42
+        assert result['float'] == 3.14
+        assert result['bool'] is True
+        assert result['none'] is None
+
+        assert result['custom'] == 'custom_str'
+        assert result['list'] == [1, 'two', 'custom_str']
+        assert result['tuple'] == [1, 2, 'custom_str']
+        assert result['nested']['inner_custom'] == 'custom_str'
+        assert result['nested']['inner_normal'] == 'value'
+
+    def test_normalize_large_integers_to_strings(self):
+        """Test the normalize_large_integers_to_strings utility function."""
+
+        test_data = {
+            'small_int': 42,
+            'large_int': 9999999999999999999,
+            'negative_large': -9999999999999999999,
+            'float': 3.14,
+            'string': 'hello',
+            'list': [123, 9999999999999999999, 'text'],
+            'nested': {'inner_large': 9999999999999999999, 'inner_small': 100},
+        }
+
+        result = proto_utils.normalize_large_integers_to_strings(test_data)
+
+        assert result['small_int'] == 42
+        assert isinstance(result['small_int'], int)
+
+        assert result['large_int'] == '9999999999999999999'
+        assert isinstance(result['large_int'], str)
+        assert result['negative_large'] == '-9999999999999999999'
+        assert isinstance(result['negative_large'], str)
+
+        assert result['float'] == 3.14
+        assert result['string'] == 'hello'
+        assert result['list'] == [123, '9999999999999999999', 'text']
+        assert result['nested']['inner_large'] == '9999999999999999999'
+        assert result['nested']['inner_small'] == 100
+
+    def test_parse_string_integers_in_dict(self):
+        """Test the parse_string_integers_in_dict utility function."""
+
+        test_data = {
+            'regular_string': 'hello',
+            'numeric_string_small': '123',
+            'numeric_string_large': '9999999999999999999',
+            'negative_large_string': '-9999999999999999999',
+            'float_string': '3.14',
+            'mixed_string': '123abc',
+            'int': 42,
+            'list': ['hello', '9999999999999999999', '123'],
+            'nested': {
+                'inner_large_string': '9999999999999999999',
+                'inner_regular': 'value',
+            },
+        }
+
+        result = proto_utils.parse_string_integers_in_dict(test_data)
+
+        assert result['regular_string'] == 'hello'
+        assert result['numeric_string_small'] == '123'
+        assert result['float_string'] == '3.14'
+        assert result['mixed_string'] == '123abc'
+
+        assert result['numeric_string_large'] == 9999999999999999999
+        assert isinstance(result['numeric_string_large'], int)
+        assert result['negative_large_string'] == -9999999999999999999
+        assert isinstance(result['negative_large_string'], int)
+
+        assert result['int'] == 42
+        assert result['list'] == ['hello', 9999999999999999999, '123']
+        assert result['nested']['inner_large_string'] == 9999999999999999999
+
+
+class TestFieldIsRepeatedFallback:
+    """Test _field_is_repeated handles both old and new protobuf descriptor APIs."""
+
+    def test_uses_is_repeated_when_available(self):
+        """protobuf>=6.31 exposes is_repeated; the helper should use it directly."""
+
+        class FakeField:
+            is_repeated = True
+            label = 3
+
+        assert proto_utils._field_is_repeated(FakeField())
+
+        class FakeFieldNotRepeated:
+            is_repeated = False
+            label = 1
+
+        assert not proto_utils._field_is_repeated(FakeFieldNotRepeated())
+
+    def test_falls_back_to_label_when_is_repeated_missing(self):
+        """protobuf<6.31 (floor >=5.29.5) lacks is_repeated; fall back to label."""
+
+        class FakeOldFieldRepeated:
+            label = FieldDescriptor.LABEL_REPEATED
+
+        assert proto_utils._field_is_repeated(FakeOldFieldRepeated())
+
+        class FakeOldFieldOptional:
+            label = FieldDescriptor.LABEL_OPTIONAL
+
+        assert not proto_utils._field_is_repeated(FakeOldFieldOptional())
+
+
+class TestRestParams:
+    """Unit tests for REST parameter conversion."""
+
+    @pytest.mark.parametrize(
+        ('values', 'expected'),
+        [
+            ([], None),
+            (['true'], True),
+            (['false'], False),
+            (['TRUE'], True),
+            (['False'], False),
+            (['true', 'false'], False),
+            (['false', 'true'], True),
+            (['garbage', 'true'], True),
+        ],
+    )
+    def test_boolean_query_values(
+        self, values: list[str], expected: bool | None
+    ) -> None:
+        message = ListTasksRequest()
+
+        proto_utils.parse_params(
+            QueryParams([('includeArtifacts', value) for value in values]),
+            message,
+        )
+
+        assert message.HasField('include_artifacts') is (expected is not None)
+        assert message.include_artifacts is bool(expected)
+
+    @pytest.mark.parametrize(
+        'value', ['garbage', '', '0', '1', ' ', ' true ', 'private-query-value']
+    )
+    @pytest.mark.parametrize('prefix', [[], ['true']])
+    def test_invalid_boolean_query_values(
+        self, value: str, prefix: list[str]
+    ) -> None:
+        with pytest.raises(ParseError, match='includeArtifacts') as error:
+            proto_utils.parse_params(
+                QueryParams(
+                    [('includeArtifacts', item) for item in [*prefix, value]]
+                ),
+                ListTasksRequest(),
+            )
+
+        if value.strip():
+            assert value not in str(error.value)
+
+    def test_rest_params_roundtrip(self):
+        """Test the comprehensive roundtrip conversion for REST parameters."""
+
+        original = ListTasksRequest(
+            tenant='tenant-1',
+            context_id='ctx-1',
+            status=TaskState.TASK_STATE_WORKING,
+            page_size=10,
+            include_artifacts=True,
+            status_timestamp_after=Parse('"2024-03-09T16:00:00Z"', Timestamp()),
+            history_length=5,
+        )
+
+        query_params = self._message_to_rest_params(original)
+
+        assert dict(query_params) == {
+            'tenant': 'tenant-1',
+            'contextId': 'ctx-1',
+            'status': 'TASK_STATE_WORKING',
+            'pageSize': '10',
+            'includeArtifacts': 'true',
+            'statusTimestampAfter': '2024-03-09T16:00:00Z',
+            'historyLength': '5',
+        }
+
+        converted = ListTasksRequest()
+        proto_utils.parse_params(QueryParams(query_params), converted)
+
+        assert converted == original
+
+    @pytest.mark.parametrize(
+        'query_string',
+        [
+            'id=skill-1&tags=tag1&tags=tag2&tags=tag3',
+            'id=skill-1&tags=tag1,tag2,tag3',
+        ],
+    )
+    def test_repeated_fields_parsing(self, query_string: str):
+        """Test parsing of repeated fields using different query string formats."""
+        query_params = QueryParams(query_string)
+
+        converted = AgentSkill()
+        proto_utils.parse_params(query_params, converted)
+
+        assert converted == AgentSkill(
+            id='skill-1', tags=['tag1', 'tag2', 'tag3']
+        )
+
+    def _message_to_rest_params(self, message: ProtobufMessage) -> QueryParams:
+        """Converts a message to REST query parameters."""
+        rest_dict = MessageToDict(message)
+        return httpx.Request(
+            'GET', 'http://api.example.com', params=rest_dict
+        ).url.params
+
+
+class TestValidateProtoRequiredFields:
+    """Tests for validate_proto_required_fields function."""
+
+    def test_valid_required_fields(self):
+        """Test with all required fields present."""
+        msg = Message(
+            message_id='msg-1',
+            role=Role.ROLE_USER,
+            parts=[Part(text='hello')],
+        )
+        proto_utils.validate_proto_required_fields(msg)
+
+    def test_missing_required_fields(self):
+        """Test with empty message raising InvalidParamsError containing all errors."""
+        msg = Message()
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.validate_proto_required_fields(msg)
+
+        err = exc_info.value
+        errors = err.data.get('errors', []) if err.data else []
+
+        assert {e['field'] for e in errors} == {'message_id', 'role', 'parts'}
+
+    def test_repeated_nested_message_validation(self):
+        """Test _recurse_validation for repeated message fields (Task.history)."""
+        task = Task(
+            id='task-1',
+            context_id='ctx-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            history=[Message()],  # empty message — missing required fields
+        )
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.validate_proto_required_fields(task)
+
+        err = exc_info.value
+        errors = err.data.get('errors', []) if err.data else []
+
+        fields = [e['field'] for e in errors]
+        assert 'history[0].message_id' in fields
+        assert 'history[0].role' in fields
+        assert 'history[0].parts' in fields
+
+    def test_nested_required_fields(self):
+        """Test nested required fields inside TaskStatus."""
+        # Task Status requires 'state'
+        task = Task(id='task-1', status=TaskStatus())
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.validate_proto_required_fields(task)
+
+        err = exc_info.value
+        errors = err.data.get('errors', []) if err.data else []
+
+        fields = [e['field'] for e in errors]
+        assert 'status.state' in fields
+
+
+class TestWarnOnMissingRequiredFields:
+    """Tests for warn_on_missing_required_fields function."""
+
+    def test_complete_message_returns_true_without_logging(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        msg = Message(
+            message_id='msg-1',
+            role=Role.ROLE_USER,
+            parts=[Part(text='hello')],
+        )
+        with caplog.at_level(logging.WARNING, logger=proto_utils.__name__):
+            assert proto_utils.warn_on_missing_required_fields(msg, 'test:')
+        assert caplog.records == []
+
+    def test_missing_fields_are_logged_instead_of_raised(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        with caplog.at_level(logging.WARNING, logger=proto_utils.__name__):
+            assert not proto_utils.warn_on_missing_required_fields(
+                Message(), 'message passed to test:'
+            )
+        [record] = caplog.records
+        assert record.levelno == logging.WARNING
+        assert record.getMessage() == (
+            'message passed to test: Message is not spec-compliant - '
+            'REQUIRED fields missing or empty: message_id, role, parts. '
+            'This is allowed and does not raise, but it may not verify or '
+            'interoperate across SDKs and could be rejected in a future '
+            'major release. See '
+            'https://a2a-protocol.org/latest/specification/#57-field-presence-and-optionality'
+        )
+
+    def test_non_message_objects_are_not_checked(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        with caplog.at_level(logging.WARNING, logger=proto_utils.__name__):
+            assert proto_utils.warn_on_missing_required_fields(
+                cast('Any', object()), 'test:'
+            )
+        assert caplog.records == []
+
+    def test_nested_missing_fields_are_reported_with_their_path(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        task = Task(
+            id='task-1',
+            context_id='ctx-1',
+            status=TaskStatus(state=TaskState.TASK_STATE_WORKING),
+            history=[Message()],
+        )
+        with caplog.at_level(logging.WARNING, logger=proto_utils.__name__):
+            assert not proto_utils.warn_on_missing_required_fields(
+                task, 'test:'
+            )
+        assert 'history[0].message_id' in caplog.text
+
+    def test_empty_repeated_field_is_reported(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        msg = Message(message_id='msg-1', role=Role.ROLE_USER, parts=[])
+        with caplog.at_level(logging.WARNING, logger=proto_utils.__name__):
+            assert not proto_utils.warn_on_missing_required_fields(msg, 'test:')
+        assert 'REQUIRED fields missing or empty: parts.' in caplog.text
+
+
+class TestParseLenient:
+    """Spec 5.7: unrecognized fields are ignored (issue #1341)."""
+
+    def test_parses_dict_and_ignores_unrecognized_fields(self) -> None:
+        """Unknown keys are skipped at every depth; known ones still parse."""
+        task = proto_utils.parse_lenient(
+            {
+                'id': 'task-1',
+                'status': {
+                    'state': 'TASK_STATE_COMPLETED',
+                    'someNestedField': 'y',
+                },
+                'someNewField': 'x',
+            },
+            Task(),
+        )
+
+        assert task.id == 'task-1'
+        assert task.status.state == TaskState.TASK_STATE_COMPLETED
+
+    def test_parses_text_and_ignores_unrecognized_fields(self) -> None:
+        """Raw ProtoJSON takes the Parse path rather than ParseDict."""
+        event = proto_utils.parse_lenient(
+            '{"message": {"messageId": "r1"}, "someNewField": "x"}',
+            StreamResponse(),
+        )
+
+        assert event.message.message_id == 'r1'
+
+    def test_malformed_known_field_still_raises(self) -> None:
+        """Leniency covers unknown names, not a known field of the wrong type."""
+        with pytest.raises(ParseError):
+            proto_utils.parse_lenient({'messageId': 5}, Message())
+
+    def test_invalid_utf8_bytes_raise_parse_error(self) -> None:
+        """Bytes that are not UTF-8 are malformed JSON, not an internal error."""
+        with pytest.raises(ParseError):
+            proto_utils.parse_lenient(b'{"messageId": "\xff"}', Message())
+
+    @pytest.mark.parametrize(
+        'data',
+        [[], None, 0, True],
+        ids=['empty-list', 'none', 'int', 'bool'],
+    )
+    def test_decoded_value_that_is_not_an_object_raises(
+        self, data: Any
+    ) -> None:
+        """A decoded value that is not a dict is not read as an empty message."""
+        with pytest.raises(ParseError, match='Expected a JSON object'):
+            proto_utils.parse_lenient(data, Task())
+
+    def test_str_is_parsed_as_text_not_as_decoded_value(self) -> None:
+        """A str is raw ProtoJSON text, so it never reaches the object check."""
+        with pytest.raises(ParseError, match='Failed to load JSON'):
+            proto_utils.parse_lenient('id', Task())
diff --git a/tests/utils/test_signing.py b/tests/utils/test_signing.py
new file mode 100644
index 000000000..241820826
--- /dev/null
+++ b/tests/utils/test_signing.py
@@ -0,0 +1,339 @@
+import logging
+
+from typing import Any
+
+import pytest
+
+from a2a.types.a2a_pb2 import (
+    AgentCapabilities,
+    AgentCard,
+    AgentCardSignature,
+    AgentInterface,
+    AgentSkill,
+)
+from a2a.utils import signing
+from cryptography.hazmat.primitives.asymmetric import ec
+from jwt.utils import base64url_encode
+
+
+def create_key_provider(verification_key: Any):
+    """Creates a key provider function for testing."""
+
+    def key_provider(kid: str | None, jku: str | None):
+        return verification_key
+
+    return key_provider
+
+
+@pytest.fixture
+def sample_agent_card() -> AgentCard:
+    return AgentCard(
+        name='Test Agent',
+        description='A test agent',
+        supported_interfaces=[
+            AgentInterface(
+                url='http://localhost',
+                protocol_binding='HTTP+JSON',
+            )
+        ],
+        version='1.0.0',
+        capabilities=AgentCapabilities(
+            streaming=None,
+            push_notifications=True,
+        ),
+        default_input_modes=['text/plain'],
+        default_output_modes=['text/plain'],
+        documentation_url=None,
+        icon_url='',
+        skills=[
+            AgentSkill(
+                id='skill1',
+                name='Test Skill',
+                description='A test skill',
+                tags=['test'],
+            )
+        ],
+    )
+
+
+def test_signer_and_verifier_symmetric(sample_agent_card: AgentCard):
+    """Test the agent card signing and verification process with symmetric key encryption."""
+    key = 'key12345'
+    wrong_key = 'wrongkey'
+
+    agent_card_signer = signing.create_agent_card_signer(
+        signing_key=key,
+        protected_header={
+            'alg': 'HS384',
+            'kid': 'key1',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+    signed_card = agent_card_signer(sample_agent_card)
+
+    assert signed_card.signatures is not None
+    assert len(signed_card.signatures) == 1
+    signature = signed_card.signatures[0]
+    assert signature.protected is not None
+    assert signature.signature is not None
+
+    verifier = signing.create_signature_verifier(
+        create_key_provider(key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    try:
+        verifier(signed_card)
+    except signing.InvalidSignaturesError:
+        pytest.fail('Signature verification failed with correct key')
+
+    verifier_wrong_key = signing.create_signature_verifier(
+        create_key_provider(wrong_key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    with pytest.raises(signing.InvalidSignaturesError):
+        verifier_wrong_key(signed_card)
+
+
+def test_signer_and_verifier_symmetric_multiple_signatures(
+    sample_agent_card: AgentCard,
+):
+    """Test the agent card signing and verification process with symmetric key encryption.
+    This test adds a signature to the AgentCard before signing."""
+    encoded_header = base64url_encode(
+        b'{"alg": "HS256", "kid": "old_key"}'
+    ).decode('utf-8')
+    sample_agent_card.signatures.extend(
+        [
+            AgentCardSignature(
+                protected=encoded_header, signature='old_signature'
+            )
+        ]
+    )
+    key = 'key12345'
+    wrong_key = 'wrongkey'
+
+    agent_card_signer = signing.create_agent_card_signer(
+        signing_key=key,
+        protected_header={
+            'alg': 'HS384',
+            'kid': 'key1',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+    signed_card = agent_card_signer(sample_agent_card)
+
+    assert signed_card.signatures is not None
+    assert len(signed_card.signatures) == 2
+    signature = signed_card.signatures[1]
+    assert signature.protected is not None
+    assert signature.signature is not None
+
+    verifier = signing.create_signature_verifier(
+        create_key_provider(key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    try:
+        verifier(signed_card)
+    except signing.InvalidSignaturesError:
+        pytest.fail('Signature verification failed with correct key')
+
+    verifier_wrong_key = signing.create_signature_verifier(
+        create_key_provider(wrong_key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    with pytest.raises(signing.InvalidSignaturesError):
+        verifier_wrong_key(signed_card)
+
+
+@pytest.mark.parametrize(
+    'protected',
+    [
+        pytest.param('!!!not-base64url!!!', id='invalid-base64url'),
+        pytest.param(
+            base64url_encode(b'\xff').decode('utf-8'), id='invalid-utf8'
+        ),
+        pytest.param(base64url_encode(b'{').decode('utf-8'), id='invalid-json'),
+        pytest.param(base64url_encode(b'[]').decode('utf-8'), id='non-object'),
+    ],
+)
+def test_verifier_skips_malformed_protected_header(
+    sample_agent_card: AgentCard,
+    protected: str,
+):
+    key = 'key12345'
+    signer = signing.create_agent_card_signer(
+        signing_key=key,
+        protected_header={'alg': 'HS384', 'kid': 'key1', 'jku': None},
+    )
+    verifier = signing.create_signature_verifier(
+        create_key_provider(key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    malformed = AgentCardSignature(protected=protected, signature='invalid')
+
+    invalid_card = AgentCard()
+    invalid_card.CopyFrom(sample_agent_card)
+    invalid_card.signatures.append(malformed)
+    with pytest.raises(signing.InvalidSignaturesError):
+        verifier(invalid_card)
+
+    valid_card = signer(sample_agent_card)
+    valid_card.signatures.insert(0, malformed)
+    verifier(valid_card)
+
+
+def test_signer_and_verifier_asymmetric(sample_agent_card: AgentCard):
+    """Test the agent card signing and verification process with an asymmetric key encryption."""
+    private_key = ec.generate_private_key(ec.SECP256R1())
+    public_key = private_key.public_key()
+    private_key_error = ec.generate_private_key(ec.SECP256R1())
+    public_key_error = private_key_error.public_key()
+
+    agent_card_signer = signing.create_agent_card_signer(
+        signing_key=private_key,
+        protected_header={
+            'alg': 'ES256',
+            'kid': 'key2',
+            'jku': None,
+            'typ': 'JOSE',
+        },
+    )
+    signed_card = agent_card_signer(sample_agent_card)
+
+    assert signed_card.signatures is not None
+    assert len(signed_card.signatures) == 1
+    signature = signed_card.signatures[0]
+    assert signature.protected is not None
+    assert signature.signature is not None
+
+    verifier = signing.create_signature_verifier(
+        create_key_provider(public_key), ['HS256', 'HS384', 'ES256', 'RS256']
+    )
+    try:
+        verifier(signed_card)
+    except signing.InvalidSignaturesError:
+        pytest.fail('Signature verification failed with correct key')
+
+    verifier_wrong_key = signing.create_signature_verifier(
+        create_key_provider(public_key_error),
+        ['HS256', 'HS384', 'ES256', 'RS256'],
+    )
+    with pytest.raises(signing.InvalidSignaturesError):
+        verifier_wrong_key(signed_card)
+
+
+def test_canonicalize_agent_card(sample_agent_card: AgentCard):
+    """Test canonicalize_agent_card with defaults, optionals, and exceptions.
+
+    - extensions is omitted as it's not set and optional.
+    - protocolVersion is included because it's always added by canonicalize_agent_card.
+    - signatures should be omitted.
+    """
+    expected_jcs = (
+        '{"capabilities":{"pushNotifications":true},'
+        '"defaultInputModes":["text/plain"],"defaultOutputModes":["text/plain"],'
+        '"description":"A test agent","name":"Test Agent",'
+        '"skills":[{"description":"A test skill","id":"skill1","name":"Test Skill","tags":["test"]}],'
+        '"supportedInterfaces":[{"protocolBinding":"HTTP+JSON","url":"http://localhost"}],'
+        '"version":"1.0.0"}'
+    )
+    result = signing._canonicalize_agent_card(sample_agent_card)
+    assert result == expected_jcs
+
+
+def test_canonicalize_agent_card_preserves_false_capability(
+    sample_agent_card: AgentCard,
+):
+    """Regression #692: streaming=False must not be stripped from canonical JSON."""
+    sample_agent_card.capabilities.streaming = False
+    result = signing._canonicalize_agent_card(sample_agent_card)
+    assert '"streaming":false' in result
+
+
+@pytest.mark.parametrize(
+    'input_val',
+    [
+        pytest.param({'a': ''}, id='empty-string'),
+        pytest.param({'a': []}, id='empty-list'),
+        pytest.param({'a': {}}, id='empty-dict'),
+        pytest.param({'a': {'b': []}}, id='nested-empty'),
+        pytest.param({'a': '', 'b': [], 'c': {}}, id='all-empties'),
+        pytest.param({'a': {'b': {'c': ''}}}, id='deeply-nested'),
+    ],
+)
+def test_clean_empty_removes_empties(input_val):
+    """_clean_empty removes empty strings, lists, and dicts recursively."""
+    assert signing._clean_empty(input_val) is None
+
+
+def test_clean_empty_top_level_list_becomes_none():
+    """Top-level list that becomes empty after cleaning should return None."""
+    assert signing._clean_empty(['', {}, []]) is None
+
+
+@pytest.mark.parametrize(
+    'input_val,expected',
+    [
+        pytest.param({'retries': 0}, {'retries': 0}, id='int-zero'),
+        pytest.param({'enabled': False}, {'enabled': False}, id='bool-false'),
+        pytest.param({'score': 0.0}, {'score': 0.0}, id='float-zero'),
+        pytest.param([0, 1, 2], [0, 1, 2], id='zero-in-list'),
+        pytest.param([False, True], [False, True], id='false-in-list'),
+        pytest.param(
+            {'config': {'max_retries': 0, 'name': 'agent'}},
+            {'config': {'max_retries': 0, 'name': 'agent'}},
+            id='nested-zero',
+        ),
+    ],
+)
+def test_clean_empty_preserves_falsy_values(input_val, expected):
+    """_clean_empty preserves legitimate falsy values (0, False, 0.0)."""
+    assert signing._clean_empty(input_val) == expected
+
+
+@pytest.mark.parametrize(
+    'input_val,expected',
+    [
+        pytest.param(
+            {'count': 0, 'label': '', 'items': []},
+            {'count': 0},
+            id='falsy-with-empties',
+        ),
+        pytest.param(
+            {'a': 0, 'b': 'hello', 'c': False, 'd': ''},
+            {'a': 0, 'b': 'hello', 'c': False},
+            id='mixed-types',
+        ),
+        pytest.param(
+            {'name': 'agent', 'retries': 0, 'tags': [], 'desc': ''},
+            {'name': 'agent', 'retries': 0},
+            id='realistic-mixed',
+        ),
+    ],
+)
+def test_clean_empty_mixed(input_val, expected):
+    """_clean_empty handles mixed empty and falsy values correctly."""
+    assert signing._clean_empty(input_val) == expected
+
+
+def test_clean_empty_does_not_mutate_input():
+    """_clean_empty should not mutate the original input object."""
+    original = {'a': '', 'b': 1, 'c': {'d': ''}}
+    original_copy = {
+        'a': '',
+        'b': 1,
+        'c': {'d': ''},
+    }
+
+    signing._clean_empty(original)
+
+    assert original == original_copy
+
+
+def test_canonicalize_agent_card_warns_about_missing_required_fields(
+    caplog: pytest.LogCaptureFixture,
+):
+    with caplog.at_level(logging.WARNING, logger='a2a.utils.proto_utils'):
+        signing._canonicalize_agent_card(AgentCard(name='partial'))
+    [record] = caplog.records
+    assert record.getMessage().startswith(
+        'agent_card passed to _canonicalize_agent_card: AgentCard is not '
+        'spec-compliant'
+    )
diff --git a/tests/utils/test_signing_interop.py b/tests/utils/test_signing_interop.py
new file mode 100644
index 000000000..6e6ec9757
--- /dev/null
+++ b/tests/utils/test_signing_interop.py
@@ -0,0 +1,78 @@
+"""Cross-SDK Agent Card signature tests.
+
+`signing_interop_vectors.json` holds one card signed four ways: by this SDK,
+by @a2a-js/sdk, by a2a-go and by an independent reference signer. The card
+carries every REQUIRED field and no field at its default value, so the
+canonical readings in use today agree on its bytes, and those expectations
+hold however a2aproject/A2A#2122 is settled: a card another SDK signed still
+verifies here.
+"""
+
+import json
+
+from pathlib import Path
+
+import pytest
+
+from a2a.types import AgentCard
+from a2a.utils import signing
+from google.protobuf import json_format
+from jwt import PyJWK
+
+
+_HERE = Path(__file__).parent
+_VECTORS = json.loads(
+    (_HERE / 'signing_interop_vectors.json').read_text(encoding='utf-8')
+)
+_ACCEPT = [v for v in _VECTORS['vectors'] if v['disposition'] == 'MUST-ACCEPT']
+_REJECT = [v for v in _VECTORS['vectors'] if v['disposition'] == 'MUST-REJECT']
+
+
+def _key_provider(jwks: dict):
+    def provide(kid: str | None, jku: str | None) -> PyJWK:
+        for key in jwks['keys']:
+            if key['kid'] == kid:
+                return PyJWK(key)
+        raise ValueError(f'kid not in key set: {kid}')
+
+    return provide
+
+
+def _card(served: dict) -> AgentCard:
+    return json_format.ParseDict(served, AgentCard())
+
+
+_VERIFY = signing.create_signature_verifier(
+    _key_provider({'keys': [_VECTORS['test_key']['jwk']]}), ['ES256']
+)
+
+
+def test_vector_corpus_is_complete():
+    """The corpus must be whole; a partially loaded corpus passes vacuously."""
+    assert len(_ACCEPT) == _VECTORS['counts']['accept'] == 4
+    assert len(_REJECT) == _VECTORS['counts']['reject'] == 1
+    assert {v['signer'] for v in _ACCEPT} >= {
+        'a2a-sdk 1.2.1',
+        '@a2a-js/sdk 1.3.0',
+        'a2a-go main 534a60fc',
+    }
+
+
+@pytest.mark.parametrize('vector', _ACCEPT, ids=lambda v: v['id'])
+def test_card_signed_by_any_sdk_verifies(vector):
+    """A card signed by any SDK verifies here."""
+    _VERIFY(_card(vector['served_card']))
+
+
+@pytest.mark.parametrize('vector', _ACCEPT, ids=lambda v: v['id'])
+def test_card_canonical_bytes_are_the_shared_form(vector):
+    """The bytes every SDK and every reading agree on, byte for byte."""
+    canonical = signing._canonicalize_agent_card(_card(vector['served_card']))
+    assert canonical.encode('utf-8').hex() == vector['canonical_utf8_hex']
+
+
+@pytest.mark.parametrize('vector', _REJECT, ids=lambda v: v['id'])
+def test_card_edited_after_signing_is_rejected(vector):
+    """A signature over other bytes must not verify."""
+    with pytest.raises(signing.InvalidSignaturesError):
+        _VERIFY(_card(vector['served_card']))
diff --git a/tests/utils/test_task.py b/tests/utils/test_task.py
new file mode 100644
index 000000000..2ce2f9e27
--- /dev/null
+++ b/tests/utils/test_task.py
@@ -0,0 +1,148 @@
+import unittest
+
+from base64 import urlsafe_b64encode
+
+import pytest
+
+from a2a.helpers.proto_helpers import new_task
+from a2a.types.a2a_pb2 import (
+    Artifact,
+    GetTaskRequest,
+    Message,
+    Part,
+    Role,
+    SendMessageConfiguration,
+    TaskState,
+)
+from a2a.utils.errors import InvalidParamsError
+from a2a.utils.task import (
+    ListTasksCursor,
+    apply_history_length,
+    decode_list_tasks_cursor,
+    decode_page_token,
+    encode_list_tasks_cursor,
+    encode_page_token,
+)
+
+
+class TestTask(unittest.TestCase):
+    page_token = 'd47a95ba-0f39-4459-965b-3923cdd2ff58'
+    encoded_page_token = 'ZDQ3YTk1YmEtMGYzOS00NDU5LTk2NWItMzkyM2NkZDJmZjU4'  # base64 for 'd47a95ba-0f39-4459-965b-3923cdd2ff58'
+
+    def test_encode_page_token(self):
+        assert encode_page_token(self.page_token) == self.encoded_page_token
+
+    def test_decode_page_token_succeeds(self):
+        assert decode_page_token(self.encoded_page_token) == self.page_token
+
+    def test_decode_page_token_fails(self):
+        with pytest.raises(InvalidParamsError) as excinfo:
+            decode_page_token('invalid')
+
+        assert 'Token is not a valid base64-encoded cursor.' in str(
+            excinfo.value
+        )
+
+
+@pytest.mark.parametrize(
+    'cursor',
+    [
+        ListTasksCursor(timestamp_ns=1_735_689_600_123_000_001, task_id='t-1'),
+        ListTasksCursor(timestamp_ns=-1, task_id='before-epoch'),
+        ListTasksCursor(timestamp_ns=None, task_id='no-timestamp'),
+        ListTasksCursor(timestamp_ns=0, task_id='ünïcode/+='),
+        ListTasksCursor(timestamp_ns=1, task_id='x' * 1_000),
+    ],
+)
+def test_list_tasks_cursor_round_trips(cursor: ListTasksCursor) -> None:
+    token = encode_list_tasks_cursor(cursor)
+
+    assert decode_list_tasks_cursor(token) == cursor
+    # Safe to put in a query string without escaping.
+    assert not set(token) & set('+/=')
+
+
+def test_legacy_task_id_token_is_not_a_cursor() -> None:
+    assert decode_list_tasks_cursor(encode_page_token('task-1')) is None
+    assert decode_list_tasks_cursor(encode_page_token('{"ts":1}')) is None
+    assert decode_list_tasks_cursor('invalid') is None
+
+
+@pytest.mark.parametrize(
+    'payload',
+    [
+        b'{"ts":1}',
+        b'{"id":"t"}',
+        b'{"ts":1,"id":"t","extra":0}',
+        b'{"ts":1,"id":""}',
+        b'{"ts":"1","id":"t"}',
+        b'{"ts":true,"id":"t"}',
+        b'{"ts":1.5,"id":"t"}',
+    ],
+)
+def test_incomplete_cursor_token_is_not_a_cursor(payload: bytes) -> None:
+    """Falls back to the legacy path, which rejects it as an unknown task."""
+    token = urlsafe_b64encode(payload).decode().rstrip('=')
+
+    assert decode_list_tasks_cursor(token) is None
+
+
+def test_cursor_sort_key_orders_missing_timestamps_last() -> None:
+    dated = ListTasksCursor(timestamp_ns=0, task_id='a')
+    undated = ListTasksCursor(timestamp_ns=None, task_id='z')
+
+    assert undated.sort_key() < dated.sort_key()
+
+
+class TestApplyHistoryLength(unittest.TestCase):
+    def setUp(self):
+        self.history = [
+            Message(
+                message_id=str(i),
+                role=Role.ROLE_USER,
+                parts=[Part(text=f'msg {i}')],
+            )
+            for i in range(5)
+        ]
+        artifacts = [Artifact(artifact_id='a1', parts=[Part(text='a')])]
+        self.task = new_task(
+            task_id='t1',
+            context_id='c1',
+            state=TaskState.TASK_STATE_COMPLETED,
+            artifacts=artifacts,
+            history=self.history,
+        )
+
+    def test_none_config_returns_full_history(self):
+        result = apply_history_length(self.task, None)
+        self.assertEqual(len(result.history), 5)
+        self.assertEqual(result.history, self.history)
+
+    def test_unset_history_length_returns_full_history(self):
+        result = apply_history_length(self.task, GetTaskRequest())
+        self.assertEqual(len(result.history), 5)
+        self.assertEqual(result.history, self.history)
+
+    def test_positive_history_length_truncates(self):
+        result = apply_history_length(
+            self.task, GetTaskRequest(history_length=2)
+        )
+        self.assertEqual(len(result.history), 2)
+        self.assertEqual(result.history, self.history[-2:])
+
+    def test_large_history_length_returns_full_history(self):
+        result = apply_history_length(
+            self.task, GetTaskRequest(history_length=10)
+        )
+        self.assertEqual(len(result.history), 5)
+        self.assertEqual(result.history, self.history)
+
+    def test_zero_history_length_returns_empty_history(self):
+        result = apply_history_length(
+            self.task, SendMessageConfiguration(history_length=0)
+        )
+        self.assertEqual(len(result.history), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/utils/test_telemetry.py b/tests/utils/test_telemetry.py
new file mode 100644
index 000000000..f630df282
--- /dev/null
+++ b/tests/utils/test_telemetry.py
@@ -0,0 +1,338 @@
+import asyncio
+import importlib
+import sys
+
+from collections.abc import Callable, Generator
+from typing import Any, NoReturn
+from unittest import mock
+
+import pytest
+
+from a2a.server.events.event_queue import QueueShutDown
+from a2a.utils.telemetry import trace_class, trace_function
+
+
+@pytest.fixture
+def mock_span() -> mock.MagicMock:
+    return mock.MagicMock()
+
+
+@pytest.fixture
+def mock_tracer(mock_span: mock.MagicMock) -> mock.MagicMock:
+    tracer = mock.MagicMock()
+    tracer.start_as_current_span.return_value.__enter__.return_value = mock_span
+    tracer.start_as_current_span.return_value.__exit__.return_value = False
+    return tracer
+
+
+@pytest.fixture(autouse=True)
+def patch_trace_get_tracer(
+    mock_tracer: mock.MagicMock,
+) -> Generator[None, Any, None]:
+    with mock.patch('opentelemetry.trace.get_tracer', return_value=mock_tracer):
+        yield
+
+
+@pytest.fixture
+def reload_telemetry_module(
+    monkeypatch: pytest.MonkeyPatch,
+) -> Generator[Callable[[str | None], Any], None, None]:
+    """Fixture to handle telemetry module reloading with env var control."""
+
+    def _reload(env_value: str | None = None) -> Any:
+        if env_value is None:
+            monkeypatch.delenv(
+                'OTEL_INSTRUMENTATION_A2A_SDK_ENABLED', raising=False
+            )
+        else:
+            monkeypatch.setenv(
+                'OTEL_INSTRUMENTATION_A2A_SDK_ENABLED', env_value
+            )
+
+        sys.modules.pop('a2a.utils.telemetry', None)
+        module = importlib.import_module('a2a.utils.telemetry')
+        return module
+
+    yield _reload
+
+    # Cleanup to ensure other tests aren't affected by a "poisoned" sys.modules
+    sys.modules.pop('a2a.utils.telemetry', None)
+
+
+def test_trace_function_sync_success(mock_span: mock.MagicMock) -> None:
+    @trace_function
+    def foo(x, y):
+        return x + y
+
+    result = foo(2, 3)
+    assert result == 5
+    mock_span.set_status.assert_called()
+    mock_span.set_status.assert_any_call(mock.ANY)
+    mock_span.record_exception.assert_not_called()
+
+
+def test_trace_function_sync_exception(mock_span: mock.MagicMock) -> None:
+    @trace_function
+    def bar() -> NoReturn:
+        raise ValueError('fail')
+
+    with pytest.raises(ValueError):
+        bar()
+    mock_span.record_exception.assert_called()
+    mock_span.set_status.assert_any_call(mock.ANY, description='fail')
+
+
+def test_trace_function_sync_attribute_extractor_called(
+    mock_span: mock.MagicMock,
+) -> None:
+    called = {}
+
+    def attr_extractor(span, args, kwargs, result, exception) -> None:
+        called['called'] = True
+        assert span is mock_span
+        assert exception is None
+        assert result == 42
+
+    @trace_function(attribute_extractor=attr_extractor)
+    def foo() -> int:
+        return 42
+
+    foo()
+    assert called['called']
+
+
+def test_trace_function_sync_attribute_extractor_error_logged(
+    mock_span: mock.MagicMock,
+) -> None:
+    with mock.patch('a2a.utils.telemetry.logger') as logger:
+
+        def attr_extractor(span, args, kwargs, result, exception) -> NoReturn:
+            raise RuntimeError('attr fail')
+
+        @trace_function(attribute_extractor=attr_extractor)
+        def foo() -> int:
+            return 1
+
+        foo()
+        logger.exception.assert_any_call(
+            'attribute_extractor error in span %s',
+            'test_telemetry.foo',
+        )
+
+
+@pytest.mark.asyncio
+async def test_trace_function_async_success(mock_span: mock.MagicMock) -> None:
+    @trace_function
+    async def foo(x):
+        await asyncio.sleep(0)
+        return x * 2
+
+    result = await foo(4)
+    assert result == 8
+    mock_span.set_status.assert_called()
+    mock_span.record_exception.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_trace_function_async_exception(
+    mock_span: mock.MagicMock,
+) -> None:
+    @trace_function
+    async def bar() -> NoReturn:
+        await asyncio.sleep(0)
+        raise RuntimeError('async fail')
+
+    with pytest.raises(RuntimeError):
+        await bar()
+    mock_span.record_exception.assert_called()
+    mock_span.set_status.assert_any_call(mock.ANY, description='async fail')
+
+
+@pytest.mark.asyncio
+async def test_trace_function_async_attribute_extractor_called(
+    mock_span: mock.MagicMock,
+) -> None:
+    called = {}
+
+    def attr_extractor(span, args, kwargs, result, exception) -> None:
+        called['called'] = True
+        assert exception is None
+        assert result == 99
+
+    @trace_function(attribute_extractor=attr_extractor)
+    async def foo() -> int:
+        return 99
+
+    await foo()
+    assert called['called']
+
+
+def test_trace_function_with_args_and_attributes(
+    mock_span: mock.MagicMock,
+) -> None:
+    @trace_function(span_name='custom.span', attributes={'foo': 'bar'})
+    def foo() -> int:
+        return 1
+
+    foo()
+    mock_span.set_attribute.assert_any_call('foo', 'bar')
+
+
+def test_trace_class_exclude_list(mock_span: mock.MagicMock) -> None:
+    @trace_class(exclude_list=['skip_me'])
+    class MyClass:
+        def a(self) -> str:
+            return 'a'
+
+        def skip_me(self) -> str:
+            return 'skip'
+
+        def __str__(self) -> str:
+            return 'str'
+
+    obj = MyClass()
+    assert obj.a() == 'a'
+    assert obj.skip_me() == 'skip'
+    # Only 'a' is traced, not 'skip_me' or dunder
+    assert hasattr(obj.a, '__wrapped__')
+    assert not hasattr(obj.skip_me, '__wrapped__')
+
+
+def test_trace_class_include_list(mock_span: mock.MagicMock) -> None:
+    @trace_class(include_list=['only_this'])
+    class MyClass:
+        def only_this(self) -> str:
+            return 'yes'
+
+        def not_this(self) -> str:
+            return 'no'
+
+    obj = MyClass()
+    assert obj.only_this() == 'yes'
+    assert obj.not_this() == 'no'
+    assert hasattr(obj.only_this, '__wrapped__')
+    assert not hasattr(obj.not_this, '__wrapped__')
+
+
+def test_trace_class_dunder_not_traced(mock_span: mock.MagicMock) -> None:
+    @trace_class()
+    class MyClass:
+        def __init__(self) -> None:
+            self.x = 1
+
+        def foo(self) -> str:
+            return 'foo'
+
+    obj = MyClass()
+    assert obj.foo() == 'foo'
+    assert hasattr(obj.foo, '__wrapped__')
+    assert hasattr(obj, 'x')
+
+
+@pytest.mark.xdist_group(name='telemetry_isolation')
+@pytest.mark.parametrize(
+    'env_value,expected_tracing',
+    [
+        (None, True),  # Default: env var not set, tracing enabled
+        ('true', True),  # Explicitly enabled
+        ('True', True),  # Case insensitive
+        ('false', False),  # Disabled
+        ('', False),  # Empty string = false
+    ],
+)
+def test_env_var_controls_instrumentation(
+    reload_telemetry_module: Callable[[str | None], Any],
+    env_value: str | None,
+    expected_tracing: bool,
+) -> None:
+    """Test OTEL_INSTRUMENTATION_A2A_SDK_ENABLED controls span creation."""
+    telemetry_module = reload_telemetry_module(env_value)
+
+    is_noop = type(telemetry_module.trace).__name__ == '_NoOp'
+
+    assert is_noop != expected_tracing
+
+
+@pytest.mark.xdist_group(name='telemetry_isolation')
+def test_env_var_disabled_logs_message(
+    reload_telemetry_module: Callable[[str | None], Any],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that disabling via env var logs appropriate debug message."""
+    with caplog.at_level('DEBUG', logger='a2a.utils.telemetry'):
+        reload_telemetry_module('false')
+
+    assert (
+        'A2A OTEL instrumentation disabled via environment variable'
+        in caplog.text
+    )
+    assert 'OTEL_INSTRUMENTATION_A2A_SDK_ENABLED' in caplog.text
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('exc_cls', [asyncio.CancelledError, QueueShutDown])
+async def test_trace_function_async_non_error_exception_does_not_mark_span_error(
+    mock_span: mock.MagicMock,
+    exc_cls: type[BaseException],
+) -> None:
+    """`trace_function` records non-error exceptions but never marks span ERROR.
+
+    Covers `asyncio.CancelledError` and `QueueShutDown`.
+    """
+
+    @trace_function
+    async def non_error_exception() -> NoReturn:
+        await asyncio.sleep(0)
+        raise exc_cls('operation ended with non-error exception')
+
+    with pytest.raises(exc_cls):
+        await non_error_exception()
+
+    mock_span.record_exception.assert_called()
+    # The wrapper only passes `description=` when calling
+    # `set_status(StatusCode.ERROR, ...)`. Its absence on every call proves
+    # the span was never marked as failed.
+    for call in mock_span.set_status.call_args_list:
+        assert 'description' not in call.kwargs
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ('exc_cls', 'is_error'), [(QueueShutDown, False), (ValueError, True)]
+)
+async def test_span_status_with_real_otel_sdk(
+    exc_cls: type[Exception], is_error: bool
+) -> None:
+    """Check the status a real OTel SDK span ends with.
+
+    The mocked-tracer tests only see the wrapper's own calls. By default,
+    `start_as_current_span` also records any exception leaving its block and
+    marks the span ERROR, which would turn a `QueueShutDown` into an error
+    span and record every exception twice.
+    """
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+    from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
+        InMemorySpanExporter,
+    )
+    from opentelemetry.trace import StatusCode
+
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+
+    with mock.patch(
+        'opentelemetry.trace.get_tracer', side_effect=provider.get_tracer
+    ):
+
+        @trace_function
+        async def fail() -> NoReturn:
+            await asyncio.sleep(0)
+            raise exc_cls
+
+        with pytest.raises(exc_cls):
+            await fail()
+
+    (span,) = exporter.get_finished_spans()
+    assert (span.status.status_code is StatusCode.ERROR) is is_error
+    assert [event.name for event in span.events] == ['exception']
diff --git a/tests/utils/test_version_validation.py b/tests/utils/test_version_validation.py
new file mode 100644
index 000000000..90147022e
--- /dev/null
+++ b/tests/utils/test_version_validation.py
@@ -0,0 +1,166 @@
+"""Tests for version validation decorators."""
+
+import pytest
+
+from a2a.server.context import ServerCallContext
+from a2a.utils import constants
+from a2a.utils.errors import VersionNotSupportedError
+from a2a.utils.version_validator import validate_version
+
+
+class TestHandler:
+    @validate_version(constants.PROTOCOL_VERSION_1_0)
+    async def async_method(self, request, context: ServerCallContext):
+        return 'success'
+
+    @validate_version(constants.PROTOCOL_VERSION_1_0)
+    async def async_gen_method(self, request, context: ServerCallContext):
+        yield 'success'
+
+    @validate_version(constants.PROTOCOL_VERSION_0_3)
+    async def compat_method(self, request, context: ServerCallContext):
+        return 'success'
+
+
+@pytest.mark.asyncio
+async def test_validate_version_success():
+    handler = TestHandler()
+    context = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0'}}
+    )
+
+    result = await handler.async_method(None, context)
+    assert result == 'success'
+
+
+@pytest.mark.asyncio
+async def test_validate_version_case_insensitive():
+    handler = TestHandler()
+    # Test lowercase header name
+    context = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER.lower(): '1.0'}}
+    )
+
+    result = await handler.async_method(None, context)
+    assert result == 'success'
+
+
+@pytest.mark.asyncio
+async def test_validate_version_mismatch():
+    handler = TestHandler()
+    context = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '0.3'}}
+    )
+
+    with pytest.raises(VersionNotSupportedError) as excinfo:
+        await handler.async_method(None, context)
+    assert "A2A version '0.3' is not supported" in str(excinfo.value)
+
+
+@pytest.mark.asyncio
+async def test_validate_version_missing_defaults_to_0_3():
+    handler = TestHandler()
+    context = ServerCallContext(state={'headers': {}})
+
+    # Missing header should be interpreted as 0.3.
+    # Since async_method expects 1.0, it should fail.
+    with pytest.raises(VersionNotSupportedError) as excinfo:
+        await handler.async_method(None, context)
+    assert "A2A version '0.3' is not supported" in str(excinfo.value)
+
+    # But compat_method expects 0.3, so it should succeed.
+    result = await handler.compat_method(None, context)
+    assert result == 'success'
+
+
+@pytest.mark.asyncio
+async def test_validate_version_async_gen_success():
+    handler = TestHandler()
+    context = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0'}}
+    )
+
+    results = []
+    async for item in handler.async_gen_method(None, context):
+        results.append(item)
+
+    assert results == ['success']
+
+
+@pytest.mark.asyncio
+async def test_validate_version_async_gen_failure():
+    handler = TestHandler()
+    context = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '0.3'}}
+    )
+
+    with pytest.raises(VersionNotSupportedError):
+        async for _ in handler.async_gen_method(None, context):
+            pass
+
+
+@pytest.mark.asyncio
+async def test_validate_version_no_context():
+    handler = TestHandler()
+
+    # If no context is found, it should default to allowing the call (for safety/backward compatibility with non-context methods)
+    # although in our actual handlers context will be there.
+    result = await handler.async_method(None, None)
+    assert result == 'success'
+
+
+@pytest.mark.asyncio
+async def test_validate_version_ignore_minor_patch():
+    handler = TestHandler()
+
+    # 1.0.1 should match 1.0
+    context_patch = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0.1'}}
+    )
+    result = await handler.async_method(None, context_patch)
+    assert result == 'success'
+
+    # 1.0.0 should match 1.0
+    context_zero_patch = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0.0'}}
+    )
+    result = await handler.async_method(None, context_zero_patch)
+    assert result == 'success'
+
+    # 1.1.0 should match 1.0
+    context_diff_minor = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.1.0'}}
+    )
+    result = await handler.async_method(None, context_diff_minor)
+    assert result == 'success'
+
+    # 2.0.0 should NOT match 1.0
+    context_diff_major = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '2.0.0'}}
+    )
+    with pytest.raises(VersionNotSupportedError):
+        await handler.async_method(None, context_diff_major)
+
+
+@pytest.mark.asyncio
+async def test_validate_version_handler_expects_patch():
+    class PatchHandler:
+        @validate_version('1.0.2')
+        async def method(self, request, context: ServerCallContext):
+            return 'success'
+
+    handler = PatchHandler()
+
+    # 1.0 should match 1.0.2
+    context_no_patch = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0'}}
+    )
+    result = await handler.method(None, context_no_patch)
+    assert result == 'success'
+
+    # 1.0.5 should match 1.0.2
+    context_diff_patch = ServerCallContext(
+        state={'headers': {constants.VERSION_HEADER: '1.0.5'}}
+    )
+    result = await handler.method(None, context_diff_patch)
+    assert result == 'success'
diff --git a/uv.lock b/uv.lock
index e9e8e3139..3440dea59 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,1401 +1,1481 @@
 version = 1
-revision = 1
-requires-python = ">=3.13"
+revision = 5
+requires-python = ">=3.10"
+resolution-markers = [
+    "python_full_version >= '3.14'",
+    "python_full_version == '3.13.*'",
+    "python_full_version >= '3.11' and python_full_version < '3.13'",
+    "python_full_version < '3.11'",
+]
 
 [manifest]
 members = [
     "a2a-sdk",
-    "adk-a2a-client-example",
-    "adk-auth-example",
-    "helloworld",
-    "langgraph-example",
+    "itk-python-v10-agent",
 ]
 
 [[package]]
 name = "a2a-sdk"
-version = "0.2.0"
 source = { editable = "." }
 dependencies = [
+    { name = "culsans", marker = "python_full_version < '3.13'" },
+    { name = "google-api-core" },
+    { name = "googleapis-common-protos" },
     { name = "httpx" },
-    { name = "httpx-sse" },
+    { name = "json-rpc" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "pydantic" },
+]
+
+[package.optional-dependencies]
+all = [
+    { name = "alembic" },
+    { name = "cryptography" },
+    { name = "fastapi" },
+    { name = "grpcio" },
+    { name = "grpcio-reflection" },
+    { name = "grpcio-tools" },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-sdk" },
-    { name = "pydantic" },
+    { name = "pyjwt" },
+    { name = "sqlalchemy", extra = ["aiomysql", "aiosqlite", "asyncio", "postgresql-asyncpg"] },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+]
+db-cli = [
+    { name = "alembic" },
+]
+encryption = [
+    { name = "cryptography" },
+]
+fastapi = [
+    { name = "fastapi" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+]
+grpc = [
+    { name = "grpcio" },
+    { name = "grpcio-reflection" },
+    { name = "grpcio-tools" },
+]
+http-server = [
     { name = "sse-starlette" },
     { name = "starlette" },
-    { name = "typing-extensions" },
+]
+mysql = [
+    { name = "sqlalchemy", extra = ["aiomysql", "asyncio"] },
+]
+postgresql = [
+    { name = "sqlalchemy", extra = ["asyncio", "postgresql-asyncpg"] },
+]
+signing = [
+    { name = "pyjwt" },
+]
+sql = [
+    { name = "sqlalchemy", extra = ["aiomysql", "aiosqlite", "asyncio", "postgresql-asyncpg"] },
+]
+sqlite = [
+    { name = "sqlalchemy", extra = ["aiosqlite", "asyncio"] },
+]
+telemetry = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-sdk" },
 ]
 
 [package.dev-dependencies]
 dev = [
-    { name = "datamodel-code-generator" },
-    { name = "mypy" },
+    { name = "a2a-sdk", extra = ["all"] },
+    { name = "fastapi" },
+    { name = "pre-commit" },
+    { name = "pyjwt" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-cov" },
     { name = "pytest-mock" },
+    { name = "pytest-timeout" },
+    { name = "pytest-xdist" },
+    { name = "respx" },
+    { name = "rfc8785" },
     { name = "ruff" },
+    { name = "trio" },
+    { name = "ty" },
+    { name = "types-protobuf" },
+    { name = "types-requests" },
+    { name = "uv-dynamic-versioning" },
+    { name = "uvicorn" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "alembic", marker = "extra == 'all'", specifier = ">=1.14.0" },
+    { name = "alembic", marker = "extra == 'db-cli'", specifier = ">=1.14.0" },
+    { name = "cryptography", marker = "extra == 'all'", specifier = ">=43.0.0" },
+    { name = "cryptography", marker = "extra == 'encryption'", specifier = ">=43.0.0" },
+    { name = "culsans", marker = "python_full_version < '3.13'", specifier = ">=0.11.0" },
+    { name = "fastapi", marker = "extra == 'all'", specifier = ">=0.115.2" },
+    { name = "fastapi", marker = "extra == 'fastapi'", specifier = ">=0.115.2" },
+    { name = "google-api-core", specifier = ">=1.26.0" },
+    { name = "googleapis-common-protos", specifier = ">=1.70.0" },
+    { name = "grpcio", marker = "extra == 'all'", specifier = ">=1.60" },
+    { name = "grpcio", marker = "extra == 'grpc'", specifier = ">=1.60" },
+    { name = "grpcio-reflection", marker = "extra == 'all'", specifier = ">=1.7.0" },
+    { name = "grpcio-reflection", marker = "extra == 'grpc'", specifier = ">=1.7.0" },
+    { name = "grpcio-tools", marker = "extra == 'all'", specifier = ">=1.60" },
+    { name = "grpcio-tools", marker = "extra == 'grpc'", specifier = ">=1.60" },
     { name = "httpx", specifier = ">=0.28.1" },
-    { name = "httpx-sse", specifier = ">=0.4.0" },
-    { name = "opentelemetry-api", specifier = ">=1.33.0" },
-    { name = "opentelemetry-sdk", specifier = ">=1.33.0" },
+    { name = "json-rpc", specifier = ">=1.15.0" },
+    { name = "opentelemetry-api", marker = "extra == 'all'", specifier = ">=1.33.0" },
+    { name = "opentelemetry-api", marker = "extra == 'telemetry'", specifier = ">=1.33.0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'all'", specifier = ">=1.33.0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'telemetry'", specifier = ">=1.33.0" },
+    { name = "packaging", specifier = ">=24.0" },
+    { name = "protobuf", specifier = ">=5.29.5" },
     { name = "pydantic", specifier = ">=2.11.3" },
-    { name = "sse-starlette", specifier = ">=2.3.3" },
-    { name = "starlette", specifier = ">=0.46.2" },
-    { name = "typing-extensions", specifier = ">=4.13.2" },
-]
+    { name = "pyjwt", marker = "extra == 'all'", specifier = ">=2.0.0" },
+    { name = "pyjwt", marker = "extra == 'signing'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiomysql", "asyncio"], marker = "extra == 'all'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiomysql", "asyncio"], marker = "extra == 'mysql'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiomysql", "asyncio"], marker = "extra == 'sql'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiosqlite", "asyncio"], marker = "extra == 'all'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiosqlite", "asyncio"], marker = "extra == 'sql'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["aiosqlite", "asyncio"], marker = "extra == 'sqlite'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["asyncio", "postgresql-asyncpg"], marker = "extra == 'all'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["asyncio", "postgresql-asyncpg"], marker = "extra == 'postgresql'", specifier = ">=2.0.0" },
+    { name = "sqlalchemy", extras = ["asyncio", "postgresql-asyncpg"], marker = "extra == 'sql'", specifier = ">=2.0.0" },
+    { name = "sse-starlette", marker = "extra == 'all'" },
+    { name = "sse-starlette", marker = "extra == 'fastapi'" },
+    { name = "sse-starlette", marker = "extra == 'http-server'" },
+    { name = "starlette", marker = "extra == 'all'" },
+    { name = "starlette", marker = "extra == 'fastapi'" },
+    { name = "starlette", marker = "extra == 'http-server'" },
+]
+provides-extras = ["all", "db-cli", "encryption", "fastapi", "grpc", "http-server", "mysql", "postgresql", "signing", "sql", "sqlite", "telemetry"]
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "datamodel-code-generator", specifier = ">=0.30.0" },
-    { name = "mypy", specifier = ">=1.15.0" },
+    { name = "a2a-sdk", extras = ["all"], editable = "." },
+    { name = "fastapi", specifier = ">=0.115.2" },
+    { name = "pre-commit" },
+    { name = "pyjwt", specifier = ">=2.0.0" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "pytest-asyncio", specifier = ">=0.26.0" },
     { name = "pytest-cov", specifier = ">=6.1.1" },
     { name = "pytest-mock", specifier = ">=3.14.0" },
-    { name = "ruff", specifier = ">=0.11.6" },
-]
-
-[[package]]
-name = "adk-a2a-client-example"
-version = "0.1.0"
-source = { editable = "examples/google_adk/birthday_planner" }
-dependencies = [
-    { name = "a2a-sdk" },
-    { name = "click" },
-    { name = "dotenv" },
-    { name = "google-adk" },
-    { name = "google-genai" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "a2a-sdk", editable = "." },
-    { name = "click", specifier = ">=8.1.8" },
-    { name = "dotenv", specifier = ">=0.9.9" },
-    { name = "google-adk", specifier = ">=0.0.3" },
-    { name = "google-genai", specifier = ">=1.9.0" },
-    { name = "httpx", specifier = ">=0.28.1" },
-    { name = "pydantic", specifier = ">=2.11.4" },
-    { name = "python-dotenv", specifier = ">=1.1.0" },
-]
-
-[[package]]
-name = "adk-auth-example"
-version = "0.1.0"
-source = { editable = "examples/google_adk/calendar_agent" }
-dependencies = [
-    { name = "a2a-sdk" },
-    { name = "click" },
-    { name = "dotenv" },
-    { name = "google-adk" },
-    { name = "google-genai" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "uvicorn" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "a2a-sdk", editable = "." },
-    { name = "click", specifier = ">=8.1.8" },
-    { name = "dotenv", specifier = ">=0.9.9" },
-    { name = "google-adk", specifier = ">=0.0.3" },
-    { name = "google-genai", specifier = ">=1.9.0" },
-    { name = "httpx", specifier = ">=0.28.1" },
-    { name = "pydantic", specifier = ">=2.11.4" },
-    { name = "python-dotenv", specifier = ">=1.1.0" },
-    { name = "uvicorn", specifier = ">=0.34.2" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-xdist", specifier = ">=3.6.1" },
+    { name = "respx", specifier = ">=0.20.2" },
+    { name = "rfc8785", specifier = ">=0.1.4" },
+    { name = "ruff", specifier = ">=0.12.8" },
+    { name = "trio" },
+    { name = "ty", specifier = ">=0.0.34" },
+    { name = "types-protobuf" },
+    { name = "types-requests" },
+    { name = "uv-dynamic-versioning", specifier = ">=0.8.2" },
+    { name = "uvicorn", specifier = ">=0.35.0" },
 ]
 
 [[package]]
-name = "annotated-types"
-version = "0.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
-]
-
-[[package]]
-name = "anyio"
-version = "4.9.0"
+name = "aiologic"
+version = "0.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "idna" },
     { name = "sniffio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 },
-]
-
-[[package]]
-name = "argcomplete"
-version = "3.6.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/16/0f/861e168fc813c56a78b35f3c30d91c6757d1fd185af1110f1aec784b35d0/argcomplete-3.6.2.tar.gz", hash = "sha256:d0519b1bc867f5f4f4713c41ad0aba73a4a5f007449716b16f385f2166dc6adf", size = 73403 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/da/e42d7a9d8dd33fa775f467e4028a47936da2f01e4b0e561f9ba0d74cb0ca/argcomplete-3.6.2-py3-none-any.whl", hash = "sha256:65b3133a29ad53fb42c48cf5114752c7ab66c1c38544fdf6460f450c09b42591", size = 43708 },
-]
-
-[[package]]
-name = "authlib"
-version = "1.5.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cryptography" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/b3/5f5bc73c6558a21f951ffd267f41c6340d15f5fe0ff4b6bf37694f3558b8/authlib-1.5.2.tar.gz", hash = "sha256:fe85ec7e50c5f86f1e2603518bb3b4f632985eb4a355e52256530790e326c512", size = 153000 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/71/8dcec996ea8cc882cec9cace91ae1b630a226b88b0f04ab2ffa778f565ad/authlib-1.5.2-py2.py3-none-any.whl", hash = "sha256:8804dd4402ac5e4a0435ac49e0b6e19e395357cfa632a3f624dcb4f6df13b4b1", size = 232055 },
-]
-
-[[package]]
-name = "black"
-version = "25.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "mypy-extensions" },
-    { name = "packaging" },
-    { name = "pathspec" },
-    { name = "platformdirs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/94/49/26a7b0f3f35da4b5a65f081943b7bcd22d7002f5f0fb8098ec1ff21cb6ef/black-25.1.0.tar.gz", hash = "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666", size = 649449 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/87/0edf98916640efa5d0696e1abb0a8357b52e69e82322628f25bf14d263d1/black-25.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f", size = 1650673 },
-    { url = "https://files.pythonhosted.org/packages/52/e5/f7bf17207cf87fa6e9b676576749c6b6ed0d70f179a3d812c997870291c3/black-25.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3", size = 1453190 },
-    { url = "https://files.pythonhosted.org/packages/e3/ee/adda3d46d4a9120772fae6de454c8495603c37c4c3b9c60f25b1ab6401fe/black-25.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171", size = 1782926 },
-    { url = "https://files.pythonhosted.org/packages/cc/64/94eb5f45dcb997d2082f097a3944cfc7fe87e071907f677e80788a2d7b7a/black-25.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18", size = 1442613 },
-    { url = "https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl", hash = "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717", size = 207646 },
-]
-
-[[package]]
-name = "cachetools"
-version = "5.5.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080 },
-]
-
-[[package]]
-name = "certifi"
-version = "2025.4.26"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/9e/c05b3920a3b7d20d3d3310465f50348e5b3694f4f88c6daf736eef3024c4/certifi-2025.4.26.tar.gz", hash = "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6", size = 160705 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618 },
-]
-
-[[package]]
-name = "cffi"
-version = "1.17.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pycparser" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
-    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
-    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
-    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
-    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
-    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
-    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
-    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
-    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
-    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
-    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622 },
-    { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435 },
-    { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653 },
-    { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231 },
-    { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243 },
-    { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442 },
-    { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147 },
-    { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057 },
-    { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454 },
-    { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174 },
-    { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166 },
-    { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064 },
-    { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641 },
-    { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626 },
-]
-
-[[package]]
-name = "click"
-version = "8.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/cd/0f/62ca20172d4f87d93cf89665fbaedcd560ac48b465bd1d92bfc7ea6b0a41/click-8.2.0.tar.gz", hash = "sha256:f5452aeddd9988eefa20f90f05ab66f17fce1ee2a36907fd30b05bbb5953814d", size = 235857 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/58/1f37bf81e3c689cc74ffa42102fa8915b59085f54a6e4a80bc6265c0f6bf/click-8.2.0-py3-none-any.whl", hash = "sha256:6b303f0b2aa85f1cb4e5303078fadcbcd4e476f114fab9b5007005711839325c", size = 102156 },
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
-]
-
-[[package]]
-name = "coverage"
-version = "7.8.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/4f/2251e65033ed2ce1e68f00f91a0294e0f80c80ae8c3ebbe2f12828c4cd53/coverage-7.8.0.tar.gz", hash = "sha256:7a3d62b3b03b4b6fd41a085f3574874cf946cb4604d2b4d3e8dca8cd570ca501", size = 811872 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/21/87e9b97b568e223f3438d93072479c2f36cc9b3f6b9f7094b9d50232acc0/coverage-7.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ac46d0c2dd5820ce93943a501ac5f6548ea81594777ca585bf002aa8854cacd", size = 211708 },
-    { url = "https://files.pythonhosted.org/packages/75/be/882d08b28a0d19c9c4c2e8a1c6ebe1f79c9c839eb46d4fca3bd3b34562b9/coverage-7.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:771eb7587a0563ca5bb6f622b9ed7f9d07bd08900f7589b4febff05f469bea00", size = 211981 },
-    { url = "https://files.pythonhosted.org/packages/7a/1d/ce99612ebd58082fbe3f8c66f6d8d5694976c76a0d474503fa70633ec77f/coverage-7.8.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42421e04069fb2cbcbca5a696c4050b84a43b05392679d4068acbe65449b5c64", size = 245495 },
-    { url = "https://files.pythonhosted.org/packages/dc/8d/6115abe97df98db6b2bd76aae395fcc941d039a7acd25f741312ced9a78f/coverage-7.8.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:554fec1199d93ab30adaa751db68acec2b41c5602ac944bb19187cb9a41a8067", size = 242538 },
-    { url = "https://files.pythonhosted.org/packages/cb/74/2f8cc196643b15bc096d60e073691dadb3dca48418f08bc78dd6e899383e/coverage-7.8.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aaeb00761f985007b38cf463b1d160a14a22c34eb3f6a39d9ad6fc27cb73008", size = 244561 },
-    { url = "https://files.pythonhosted.org/packages/22/70/c10c77cd77970ac965734fe3419f2c98665f6e982744a9bfb0e749d298f4/coverage-7.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:581a40c7b94921fffd6457ffe532259813fc68eb2bdda60fa8cc343414ce3733", size = 244633 },
-    { url = "https://files.pythonhosted.org/packages/38/5a/4f7569d946a07c952688debee18c2bb9ab24f88027e3d71fd25dbc2f9dca/coverage-7.8.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f319bae0321bc838e205bf9e5bc28f0a3165f30c203b610f17ab5552cff90323", size = 242712 },
-    { url = "https://files.pythonhosted.org/packages/bb/a1/03a43b33f50475a632a91ea8c127f7e35e53786dbe6781c25f19fd5a65f8/coverage-7.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04bfec25a8ef1c5f41f5e7e5c842f6b615599ca8ba8391ec33a9290d9d2db3a3", size = 244000 },
-    { url = "https://files.pythonhosted.org/packages/6a/89/ab6c43b1788a3128e4d1b7b54214548dcad75a621f9d277b14d16a80d8a1/coverage-7.8.0-cp313-cp313-win32.whl", hash = "sha256:dd19608788b50eed889e13a5d71d832edc34fc9dfce606f66e8f9f917eef910d", size = 214195 },
-    { url = "https://files.pythonhosted.org/packages/12/12/6bf5f9a8b063d116bac536a7fb594fc35cb04981654cccb4bbfea5dcdfa0/coverage-7.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:a9abbccd778d98e9c7e85038e35e91e67f5b520776781d9a1e2ee9d400869487", size = 214998 },
-    { url = "https://files.pythonhosted.org/packages/2a/e6/1e9df74ef7a1c983a9c7443dac8aac37a46f1939ae3499424622e72a6f78/coverage-7.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:18c5ae6d061ad5b3e7eef4363fb27a0576012a7447af48be6c75b88494c6cf25", size = 212541 },
-    { url = "https://files.pythonhosted.org/packages/04/51/c32174edb7ee49744e2e81c4b1414ac9df3dacfcb5b5f273b7f285ad43f6/coverage-7.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95aa6ae391a22bbbce1b77ddac846c98c5473de0372ba5c463480043a07bff42", size = 212767 },
-    { url = "https://files.pythonhosted.org/packages/e9/8f/f454cbdb5212f13f29d4a7983db69169f1937e869a5142bce983ded52162/coverage-7.8.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e013b07ba1c748dacc2a80e69a46286ff145935f260eb8c72df7185bf048f502", size = 256997 },
-    { url = "https://files.pythonhosted.org/packages/e6/74/2bf9e78b321216d6ee90a81e5c22f912fc428442c830c4077b4a071db66f/coverage-7.8.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d766a4f0e5aa1ba056ec3496243150698dc0481902e2b8559314368717be82b1", size = 252708 },
-    { url = "https://files.pythonhosted.org/packages/92/4d/50d7eb1e9a6062bee6e2f92e78b0998848a972e9afad349b6cdde6fa9e32/coverage-7.8.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad80e6b4a0c3cb6f10f29ae4c60e991f424e6b14219d46f1e7d442b938ee68a4", size = 255046 },
-    { url = "https://files.pythonhosted.org/packages/40/9e/71fb4e7402a07c4198ab44fc564d09d7d0ffca46a9fb7b0a7b929e7641bd/coverage-7.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b87eb6fc9e1bb8f98892a2458781348fa37e6925f35bb6ceb9d4afd54ba36c73", size = 256139 },
-    { url = "https://files.pythonhosted.org/packages/49/1a/78d37f7a42b5beff027e807c2843185961fdae7fe23aad5a4837c93f9d25/coverage-7.8.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d1ba00ae33be84066cfbe7361d4e04dec78445b2b88bdb734d0d1cbab916025a", size = 254307 },
-    { url = "https://files.pythonhosted.org/packages/58/e9/8fb8e0ff6bef5e170ee19d59ca694f9001b2ec085dc99b4f65c128bb3f9a/coverage-7.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f3c38e4e5ccbdc9198aecc766cedbb134b2d89bf64533973678dfcf07effd883", size = 255116 },
-    { url = "https://files.pythonhosted.org/packages/56/b0/d968ecdbe6fe0a863de7169bbe9e8a476868959f3af24981f6a10d2b6924/coverage-7.8.0-cp313-cp313t-win32.whl", hash = "sha256:379fe315e206b14e21db5240f89dc0774bdd3e25c3c58c2c733c99eca96f1ada", size = 214909 },
-    { url = "https://files.pythonhosted.org/packages/87/e9/d6b7ef9fecf42dfb418d93544af47c940aa83056c49e6021a564aafbc91f/coverage-7.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2e4b6b87bb0c846a9315e3ab4be2d52fac905100565f4b92f02c445c8799e257", size = 216068 },
-    { url = "https://files.pythonhosted.org/packages/59/f1/4da7717f0063a222db253e7121bd6a56f6fb1ba439dcc36659088793347c/coverage-7.8.0-py3-none-any.whl", hash = "sha256:dbf364b4c5e7bae9250528167dfe40219b62e2d573c854d74be213e1e52069f7", size = 203435 },
-]
-
-[[package]]
-name = "cryptography"
-version = "44.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/53/d6/1411ab4d6108ab167d06254c5be517681f1e331f90edf1379895bcb87020/cryptography-44.0.3.tar.gz", hash = "sha256:fe19d8bc5536a91a24a8133328880a41831b6c5df54599a8417b62fe015d3053", size = 711096 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/53/c776d80e9d26441bb3868457909b4e74dd9ccabd182e10b2b0ae7a07e265/cryptography-44.0.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:962bc30480a08d133e631e8dfd4783ab71cc9e33d5d7c1e192f0b7c06397bb88", size = 6670281 },
-    { url = "https://files.pythonhosted.org/packages/6a/06/af2cf8d56ef87c77319e9086601bef621bedf40f6f59069e1b6d1ec498c5/cryptography-44.0.3-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffc61e8f3bf5b60346d89cd3d37231019c17a081208dfbbd6e1605ba03fa137", size = 3959305 },
-    { url = "https://files.pythonhosted.org/packages/ae/01/80de3bec64627207d030f47bf3536889efee8913cd363e78ca9a09b13c8e/cryptography-44.0.3-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58968d331425a6f9eedcee087f77fd3c927c88f55368f43ff7e0a19891f2642c", size = 4171040 },
-    { url = "https://files.pythonhosted.org/packages/bd/48/bb16b7541d207a19d9ae8b541c70037a05e473ddc72ccb1386524d4f023c/cryptography-44.0.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e28d62e59a4dbd1d22e747f57d4f00c459af22181f0b2f787ea83f5a876d7c76", size = 3963411 },
-    { url = "https://files.pythonhosted.org/packages/42/b2/7d31f2af5591d217d71d37d044ef5412945a8a8e98d5a2a8ae4fd9cd4489/cryptography-44.0.3-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af653022a0c25ef2e3ffb2c673a50e5a0d02fecc41608f4954176f1933b12359", size = 3689263 },
-    { url = "https://files.pythonhosted.org/packages/25/50/c0dfb9d87ae88ccc01aad8eb93e23cfbcea6a6a106a9b63a7b14c1f93c75/cryptography-44.0.3-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:157f1f3b8d941c2bd8f3ffee0af9b049c9665c39d3da9db2dc338feca5e98a43", size = 4196198 },
-    { url = "https://files.pythonhosted.org/packages/66/c9/55c6b8794a74da652690c898cb43906310a3e4e4f6ee0b5f8b3b3e70c441/cryptography-44.0.3-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:c6cd67722619e4d55fdb42ead64ed8843d64638e9c07f4011163e46bc512cf01", size = 3966502 },
-    { url = "https://files.pythonhosted.org/packages/b6/f7/7cb5488c682ca59a02a32ec5f975074084db4c983f849d47b7b67cc8697a/cryptography-44.0.3-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b424563394c369a804ecbee9b06dfb34997f19d00b3518e39f83a5642618397d", size = 4196173 },
-    { url = "https://files.pythonhosted.org/packages/d2/0b/2f789a8403ae089b0b121f8f54f4a3e5228df756e2146efdf4a09a3d5083/cryptography-44.0.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c91fc8e8fd78af553f98bc7f2a1d8db977334e4eea302a4bfd75b9461c2d8904", size = 4087713 },
-    { url = "https://files.pythonhosted.org/packages/1d/aa/330c13655f1af398fc154089295cf259252f0ba5df93b4bc9d9c7d7f843e/cryptography-44.0.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:25cd194c39fa5a0aa4169125ee27d1172097857b27109a45fadc59653ec06f44", size = 4299064 },
-    { url = "https://files.pythonhosted.org/packages/10/a8/8c540a421b44fd267a7d58a1fd5f072a552d72204a3f08194f98889de76d/cryptography-44.0.3-cp37-abi3-win32.whl", hash = "sha256:3be3f649d91cb182c3a6bd336de8b61a0a71965bd13d1a04a0e15b39c3d5809d", size = 2773887 },
-    { url = "https://files.pythonhosted.org/packages/b9/0d/c4b1657c39ead18d76bbd122da86bd95bdc4095413460d09544000a17d56/cryptography-44.0.3-cp37-abi3-win_amd64.whl", hash = "sha256:3883076d5c4cc56dbef0b898a74eb6992fdac29a7b9013870b34efe4ddb39a0d", size = 3209737 },
-    { url = "https://files.pythonhosted.org/packages/34/a3/ad08e0bcc34ad436013458d7528e83ac29910943cea42ad7dd4141a27bbb/cryptography-44.0.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:5639c2b16764c6f76eedf722dbad9a0914960d3489c0cc38694ddf9464f1bb2f", size = 6673501 },
-    { url = "https://files.pythonhosted.org/packages/b1/f0/7491d44bba8d28b464a5bc8cc709f25a51e3eac54c0a4444cf2473a57c37/cryptography-44.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3ffef566ac88f75967d7abd852ed5f182da252d23fac11b4766da3957766759", size = 3960307 },
-    { url = "https://files.pythonhosted.org/packages/f7/c8/e5c5d0e1364d3346a5747cdcd7ecbb23ca87e6dea4f942a44e88be349f06/cryptography-44.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:192ed30fac1728f7587c6f4613c29c584abdc565d7417c13904708db10206645", size = 4170876 },
-    { url = "https://files.pythonhosted.org/packages/73/96/025cb26fc351d8c7d3a1c44e20cf9a01e9f7cf740353c9c7a17072e4b264/cryptography-44.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7d5fe7195c27c32a64955740b949070f21cba664604291c298518d2e255931d2", size = 3964127 },
-    { url = "https://files.pythonhosted.org/packages/01/44/eb6522db7d9f84e8833ba3bf63313f8e257729cf3a8917379473fcfd6601/cryptography-44.0.3-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3f07943aa4d7dad689e3bb1638ddc4944cc5e0921e3c227486daae0e31a05e54", size = 3689164 },
-    { url = "https://files.pythonhosted.org/packages/68/fb/d61a4defd0d6cee20b1b8a1ea8f5e25007e26aeb413ca53835f0cae2bcd1/cryptography-44.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:cb90f60e03d563ca2445099edf605c16ed1d5b15182d21831f58460c48bffb93", size = 4198081 },
-    { url = "https://files.pythonhosted.org/packages/1b/50/457f6911d36432a8811c3ab8bd5a6090e8d18ce655c22820994913dd06ea/cryptography-44.0.3-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ab0b005721cc0039e885ac3503825661bd9810b15d4f374e473f8c89b7d5460c", size = 3967716 },
-    { url = "https://files.pythonhosted.org/packages/35/6e/dca39d553075980ccb631955c47b93d87d27f3596da8d48b1ae81463d915/cryptography-44.0.3-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:3bb0847e6363c037df8f6ede57d88eaf3410ca2267fb12275370a76f85786a6f", size = 4197398 },
-    { url = "https://files.pythonhosted.org/packages/9b/9d/d1f2fe681eabc682067c66a74addd46c887ebacf39038ba01f8860338d3d/cryptography-44.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b0cc66c74c797e1db750aaa842ad5b8b78e14805a9b5d1348dc603612d3e3ff5", size = 4087900 },
-    { url = "https://files.pythonhosted.org/packages/c4/f5/3599e48c5464580b73b236aafb20973b953cd2e7b44c7c2533de1d888446/cryptography-44.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6866df152b581f9429020320e5eb9794c8780e90f7ccb021940d7f50ee00ae0b", size = 4301067 },
-    { url = "https://files.pythonhosted.org/packages/a7/6c/d2c48c8137eb39d0c193274db5c04a75dab20d2f7c3f81a7dcc3a8897701/cryptography-44.0.3-cp39-abi3-win32.whl", hash = "sha256:c138abae3a12a94c75c10499f1cbae81294a6f983b3af066390adee73f433028", size = 2775467 },
-    { url = "https://files.pythonhosted.org/packages/c9/ad/51f212198681ea7b0deaaf8846ee10af99fba4e894f67b353524eab2bbe5/cryptography-44.0.3-cp39-abi3-win_amd64.whl", hash = "sha256:5d186f32e52e66994dce4f766884bcb9c68b8da62d61d9d215bfe5fb56d21334", size = 3210375 },
-]
-
-[[package]]
-name = "datamodel-code-generator"
-version = "0.30.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "argcomplete" },
-    { name = "black" },
-    { name = "genson" },
-    { name = "inflect" },
-    { name = "isort" },
-    { name = "jinja2" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "pyyaml" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ef/bc/627a77eafcf7101c9f5710130b2def98593709a8d29676e4a58f09cd2a23/datamodel_code_generator-0.30.1.tar.gz", hash = "sha256:d125012face4cd1eca6c9300297a1f5775a9d5ff8fc3f68d34d0944a7beea105", size = 446630 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/b3/01aab190372914399bbc77f89ac3b24b439c3d97a52a6198f1cd1396ef3a/datamodel_code_generator-0.30.1-py3-none-any.whl", hash = "sha256:9601dfa3da8aa8d8d54e182059f78836b1768a807d5c26df798db12d4054c8f3", size = 118045 },
-]
-
-[[package]]
-name = "deprecated"
-version = "1.2.18"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or python_full_version >= '3.13'" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744 }
+sdist = { url = "https://files.pythonhosted.org/packages/a8/13/50b91a3ea6b030d280d2654be97c48b6ed81753a50286ee43c646ba36d3c/aiologic-0.16.0.tar.gz", hash = "sha256:c267ccbd3ff417ec93e78d28d4d577ccca115d5797cdbd16785a551d9658858f", size = 225952, upload-time = "2025-11-27T23:48:41.195Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998 },
+    { url = "https://files.pythonhosted.org/packages/f6/27/206615942005471499f6fbc36621582e24d0686f33c74b2d018fcfd4fe67/aiologic-0.16.0-py3-none-any.whl", hash = "sha256:e00ce5f68c5607c864d26aec99c0a33a83bdf8237aa7312ffbb96805af67d8b6", size = 135193, upload-time = "2025-11-27T23:48:40.099Z" },
 ]
 
 [[package]]
-name = "docstring-parser"
-version = "0.16"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/08/12/9c22a58c0b1e29271051222d8906257616da84135af9ed167c9e28f85cb3/docstring_parser-0.16.tar.gz", hash = "sha256:538beabd0af1e2db0146b6bd3caa526c35a34d61af9fd2887f3a8a27a739aa6e", size = 26565 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/7c/e9fcff7623954d86bdc17782036cbf715ecab1bec4847c008557affe1ca8/docstring_parser-0.16-py3-none-any.whl", hash = "sha256:bf0a1387354d3691d102edef7ec124f219ef639982d096e26e3b60aeffa90637", size = 36533 },
-]
-
-[[package]]
-name = "dotenv"
-version = "0.9.9"
+name = "aiomysql"
+version = "0.3.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "python-dotenv" },
+    { name = "pymysql" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/29/e0/302aeffe8d90853556f47f3106b89c16cc2ec2a4d269bdfd82e3f4ae12cc/aiomysql-0.3.2.tar.gz", hash = "sha256:72d15ef5cfc34c03468eb41e1b90adb9fd9347b0b589114bd23ead569a02ac1a", size = 108311, upload-time = "2025-10-22T00:15:21.278Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892 },
+    { url = "https://files.pythonhosted.org/packages/4c/af/aae0153c3e28712adaf462328f6c7a3c196a1c1c27b491de4377dd3e6b52/aiomysql-0.3.2-py3-none-any.whl", hash = "sha256:c82c5ba04137d7afd5c693a258bea8ead2aad77101668044143a991e04632eb2", size = 71834, upload-time = "2025-10-22T00:15:15.905Z" },
 ]
 
 [[package]]
-name = "fastapi"
-version = "0.115.12"
+name = "aiosqlite"
+version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "starlette" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/55/ae499352d82338331ca1e28c7f4a63bfd09479b16395dce38cf50a39e2c2/fastapi-0.115.12.tar.gz", hash = "sha256:1e2c2a2646905f9e83d32f04a3f86aff4a286669c6c950ca95b5fd68c2602681", size = 295236 }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/8a/64761f4005f17809769d23e518d915db74e6310474e733e3593cfc854ef1/aiosqlite-0.22.1.tar.gz", hash = "sha256:043e0bd78d32888c0a9ca90fc788b38796843360c855a7262a532813133a0650", size = 14821, upload-time = "2025-12-23T19:25:43.997Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/b3/b51f09c2ba432a576fe63758bddc81f78f0c6309d9e5c10d194313bf021e/fastapi-0.115.12-py3-none-any.whl", hash = "sha256:e94613d6c05e27be7ffebdd6ea5f388112e5e430c8f7d6494a9d1d88d43e814d", size = 95164 },
+    { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" },
 ]
 
 [[package]]
-name = "filetype"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/29/745f7d30d47fe0f251d3ad3dc2978a23141917661998763bebb6da007eb1/filetype-1.2.0.tar.gz", hash = "sha256:66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb", size = 998020 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/79/1b8fa1bb3568781e84c9200f951c735f3f157429f44be0495da55894d620/filetype-1.2.0-py2.py3-none-any.whl", hash = "sha256:7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25", size = 19970 },
-]
-
-[[package]]
-name = "genson"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c5/cf/2303c8ad276dcf5ee2ad6cf69c4338fd86ef0f471a5207b069adf7a393cf/genson-1.3.0.tar.gz", hash = "sha256:e02db9ac2e3fd29e65b5286f7135762e2cd8a986537c075b06fc5f1517308e37", size = 34919 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/5c/e226de133afd8bb267ec27eead9ae3d784b95b39a287ed404caab39a5f50/genson-1.3.0-py3-none-any.whl", hash = "sha256:468feccd00274cc7e4c09e84b08704270ba8d95232aa280f65b986139cec67f7", size = 21470 },
-]
-
-[[package]]
-name = "google-adk"
-version = "0.5.0"
+name = "alembic"
+version = "1.18.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "authlib" },
-    { name = "click" },
-    { name = "fastapi" },
-    { name = "google-api-python-client" },
-    { name = "google-cloud-aiplatform" },
-    { name = "google-cloud-secret-manager" },
-    { name = "google-cloud-speech" },
-    { name = "google-cloud-storage" },
-    { name = "google-genai" },
-    { name = "graphviz" },
-    { name = "mcp" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-gcp-trace" },
-    { name = "opentelemetry-sdk" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "pyyaml" },
+    { name = "mako" },
     { name = "sqlalchemy" },
-    { name = "tzlocal" },
-    { name = "uvicorn" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/89/3e/90b9d622c0381aa12f861d0bc7ad10b148febb9da95a27836629aa7cf5f8/google_adk-0.5.0.tar.gz", hash = "sha256:6f6493889a02ce5ed1797caa6385307914b16dcb086bad02c1ad314d609075db", size = 1055492 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725, upload-time = "2026-02-10T16:00:47.195Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/ca/761423fed60efe07e487acc867f9d3c3bfb2cba3096bbd4a84d6ac8cddb6/google_adk-0.5.0-py3-none-any.whl", hash = "sha256:4a2f2dcad337f51779af4b654579fcc0f296d8aab5db0a7855a2275722af5a24", size = 1184678 },
+    { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893, upload-time = "2026-02-10T16:00:49.997Z" },
 ]
 
 [[package]]
-name = "google-ai-generativelanguage"
-version = "0.6.18"
+name = "annotated-doc"
+version = "0.0.4"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/eb/77/3e89a4c4200135eac74eca2f6c9153127e3719a825681ad55f5a4a58b422/google_ai_generativelanguage-0.6.18.tar.gz", hash = "sha256:274ba9fcf69466ff64e971d565884434388e523300afd468fc8e3033cd8e606e", size = 1444757 }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/77/ca2889903a2d93b3072a49056d48b3f55410219743e338a1d7f94dc6455e/google_ai_generativelanguage-0.6.18-py3-none-any.whl", hash = "sha256:13d8174fea90b633f520789d32df7b422058fd5883b022989c349f1017db7fcf", size = 1372256 },
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
 ]
 
 [[package]]
-name = "google-api-core"
-version = "2.24.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-auth" },
-    { name = "googleapis-common-protos" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/09/5c/085bcb872556934bb119e5e09de54daa07873f6866b8f0303c49e72287f7/google_api_core-2.24.2.tar.gz", hash = "sha256:81718493daf06d96d6bc76a91c23874dbf2fac0adbbf542831b805ee6e974696", size = 163516 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/95/f472d85adab6e538da2025dfca9e976a0d125cc0af2301f190e77b76e51c/google_api_core-2.24.2-py3-none-any.whl", hash = "sha256:810a63ac95f3c441b7c0e43d344e372887f62ce9071ba972eacf32672e072de9", size = 160061 },
-]
-
-[package.optional-dependencies]
-grpc = [
-    { name = "grpcio" },
-    { name = "grpcio-status" },
-]
-
-[[package]]
-name = "google-api-python-client"
-version = "2.169.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-    { name = "google-auth-httplib2" },
-    { name = "httplib2" },
-    { name = "uritemplate" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4f/e6/787c24738fc7c99de9289abe60bd64591800ae1cdf60db7b87e0e6ef9cdd/google_api_python_client-2.169.0.tar.gz", hash = "sha256:0585bb97bd5f5bf3ed8d4bf624593e4c5a14d06c811d1952b07a1f94b4d12c51", size = 12811341 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/bd/6aa93c38756cc9fc63262e0dc3d3f1ff7241ce6f413a25ad6e4a9c98b473/google_api_python_client-2.169.0-py3-none-any.whl", hash = "sha256:dae3e882dc0e6f28e60cf09c1f13fedfd881db84f824dd418aa9e44def2fe00d", size = 13323742 },
-]
-
-[[package]]
-name = "google-auth"
-version = "2.40.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cachetools" },
-    { name = "pyasn1-modules" },
-    { name = "rsa" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/94/a5/38c21d0e731bb716cffcf987bd9a3555cb95877ab4b616cfb96939933f20/google_auth-2.40.1.tar.gz", hash = "sha256:58f0e8416a9814c1d86c9b7f6acf6816b51aba167b2c76821965271bac275540", size = 280975 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/b1/1272c6e80847ba5349f5ccb7574596393d1e222543f5003cb810865c3575/google_auth-2.40.1-py2.py3-none-any.whl", hash = "sha256:ed4cae4f5c46b41bae1d19c036e06f6c371926e97b19e816fc854eff811974ee", size = 216101 },
-]
-
-[[package]]
-name = "google-auth-httplib2"
-version = "0.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-auth" },
-    { name = "httplib2" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/56/be/217a598a818567b28e859ff087f347475c807a5649296fb5a817c58dacef/google-auth-httplib2-0.2.0.tar.gz", hash = "sha256:38aa7badf48f974f1eb9861794e9c0cb2a0511a4ec0679b1f886d108f5640e05", size = 10842 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/8a/fe34d2f3f9470a27b01c9e76226965863f153d5fbe276f83608562e49c04/google_auth_httplib2-0.2.0-py2.py3-none-any.whl", hash = "sha256:b65a0a2123300dd71281a7bf6e64d65a0759287df52729bdd1ae2e47dc311a3d", size = 9253 },
-]
-
-[[package]]
-name = "google-cloud-aiplatform"
-version = "1.92.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "docstring-parser" },
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "google-cloud-bigquery" },
-    { name = "google-cloud-resource-manager" },
-    { name = "google-cloud-storage" },
-    { name = "google-genai" },
-    { name = "packaging" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-    { name = "pydantic" },
-    { name = "shapely" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/ff/0cc338abd667558cdcc73901df2f5c0060ece69b0a7114b4901adf0825ad/google_cloud_aiplatform-1.92.0.tar.gz", hash = "sha256:54e6f4ef74566d0e8d8a48e1cbe3ca46017e7a4030689d1cb1561115297630fd", size = 9110499 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/aa/21/13367593506a5bdeb090f997abadaef2cce04f129437a202ca23ffaebb7a/google_cloud_aiplatform-1.92.0-py2.py3-none-any.whl", hash = "sha256:ced3e6aca90fadb6f224eb0ee71db41b38723efe26cf46266f65601079e3b2f3", size = 7604989 },
-]
-
-[[package]]
-name = "google-cloud-bigquery"
-version = "3.32.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "google-cloud-core" },
-    { name = "google-resumable-media" },
-    { name = "packaging" },
-    { name = "python-dateutil" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/cf/174ea37f0410f0702c3582c09bae45d6f43c6eabe2858ab5fb2a4319e15f/google_cloud_bigquery-3.32.0.tar.gz", hash = "sha256:f1c53d73a6d255c8cd0ca7a0c077d95224217427a4b7dcf9913ea0298a2961e8", size = 487055 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/c3/f3f6179f54e4b4ac2c6abaa8186054fd1d7d881676bb3caef9688e5fac3d/google_cloud_bigquery-3.32.0-py3-none-any.whl", hash = "sha256:ff38d21d70c4563d2473db288d2a9fe44f071d928bbad6d029ac9ba0b8a36b7a", size = 253121 },
-]
-
-[[package]]
-name = "google-cloud-core"
-version = "2.4.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/b8/2b53838d2acd6ec6168fd284a990c76695e84c65deee79c9f3a4276f6b4f/google_cloud_core-2.4.3.tar.gz", hash = "sha256:1fab62d7102844b278fe6dead3af32408b1df3eb06f5c7e8634cbd40edc4da53", size = 35861 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/40/86/bda7241a8da2d28a754aad2ba0f6776e35b67e37c36ae0c45d49370f1014/google_cloud_core-2.4.3-py2.py3-none-any.whl", hash = "sha256:5130f9f4c14b4fafdff75c79448f9495cfade0d8775facf1b09c3bf67e027f6e", size = 29348 },
-]
-
-[[package]]
-name = "google-cloud-resource-manager"
-version = "1.14.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "grpc-google-iam-v1" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/ca/a4648f5038cb94af4b3942815942a03aa9398f9fb0bef55b3f1585b9940d/google_cloud_resource_manager-1.14.2.tar.gz", hash = "sha256:962e2d904c550d7bac48372607904ff7bb3277e3bb4a36d80cc9a37e28e6eb74", size = 446370 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/ea/a92631c358da377af34d3a9682c97af83185c2d66363d5939ab4a1169a7f/google_cloud_resource_manager-1.14.2-py3-none-any.whl", hash = "sha256:d0fa954dedd1d2b8e13feae9099c01b8aac515b648e612834f9942d2795a9900", size = 394344 },
-]
-
-[[package]]
-name = "google-cloud-secret-manager"
-version = "2.23.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "grpc-google-iam-v1" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/99/73/533fca3a94ef6cf57fbd0cf6fa57c8865ba8173542a505272869a1b7be85/google_cloud_secret_manager-2.23.3.tar.gz", hash = "sha256:598c4c0a9d10d49d500eb4aea3255dff250aa2f92c028f5c97e3b367f768c808", size = 268671 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/ec/230606fd826d466ee5b014c6a3f04d47038b1146a3a560645889817d9fea/google_cloud_secret_manager-2.23.3-py3-none-any.whl", hash = "sha256:fe06ebb2f71eb739ecc6c14ea9e8dafcb9bbc6123b78b2f8986ece6733d23a1a", size = 217097 },
-]
-
-[[package]]
-name = "google-cloud-speech"
-version = "2.32.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/dc/fc/7e47328069850f084ee17e26b5572de067e30fdab862e381702222d237b7/google_cloud_speech-2.32.0.tar.gz", hash = "sha256:89c2618b131d310c6c00e7c04d290ffa9a5d68c20191030766a7737850f04e77", size = 387621 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/a4/f41f2737cd0597f2aa5855b0a12f353fad4506868887590671230df81c77/google_cloud_speech-2.32.0-py3-none-any.whl", hash = "sha256:537b279d8697fe5b5bc5f485f2d48a6b343fc76f73385b5776806c37bc5f8ea1", size = 334148 },
-]
-
-[[package]]
-name = "google-cloud-storage"
-version = "2.19.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-    { name = "google-cloud-core" },
-    { name = "google-crc32c" },
-    { name = "google-resumable-media" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/36/76/4d965702e96bb67976e755bed9828fa50306dca003dbee08b67f41dd265e/google_cloud_storage-2.19.0.tar.gz", hash = "sha256:cd05e9e7191ba6cb68934d8eb76054d9be4562aa89dbc4236feee4d7d51342b2", size = 5535488 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/94/6db383d8ee1adf45dc6c73477152b82731fa4c4a46d9c1932cc8757e0fd4/google_cloud_storage-2.19.0-py2.py3-none-any.whl", hash = "sha256:aeb971b5c29cf8ab98445082cbfe7b161a1f48ed275822f59ed3f1524ea54fba", size = 131787 },
-]
-
-[[package]]
-name = "google-cloud-trace"
-version = "1.16.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/66/b706c1316467b8cc304e0b6c6a22414abd23e41fd4d9f6af819c0404790b/google_cloud_trace-1.16.1.tar.gz", hash = "sha256:15308b04f12d958f2b3831a4f76b97c61c0c7a46804bdc570d19024938029d9a", size = 97349 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/10/6d2189c92e8a8ecf50cd13281436f72b91d6509e31b1c21363b097561be3/google_cloud_trace-1.16.1-py3-none-any.whl", hash = "sha256:a4a6c90f7507823024c43ed7890baecf68ebd8cb20a6d7e03622c5f04087fef4", size = 103303 },
-]
-
-[[package]]
-name = "google-crc32c"
-version = "1.7.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/ae/87802e6d9f9d69adfaedfcfd599266bf386a54d0be058b532d04c794f76d/google_crc32c-1.7.1.tar.gz", hash = "sha256:2bff2305f98846f3e825dbeec9ee406f89da7962accdb29356e4eadc251bd472", size = 14495 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/72/b8d785e9184ba6297a8620c8a37cf6e39b81a8ca01bb0796d7cbb28b3386/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:df8b38bdaf1629d62d51be8bdd04888f37c451564c2042d36e5812da9eff3c35", size = 30467 },
-    { url = "https://files.pythonhosted.org/packages/34/25/5f18076968212067c4e8ea95bf3b69669f9fc698476e5f5eb97d5b37999f/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:e42e20a83a29aa2709a0cf271c7f8aefaa23b7ab52e53b322585297bb94d4638", size = 30309 },
-    { url = "https://files.pythonhosted.org/packages/92/83/9228fe65bf70e93e419f38bdf6c5ca5083fc6d32886ee79b450ceefd1dbd/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:905a385140bf492ac300026717af339790921f411c0dfd9aa5a9e69a08ed32eb", size = 33133 },
-    { url = "https://files.pythonhosted.org/packages/c3/ca/1ea2fd13ff9f8955b85e7956872fdb7050c4ace8a2306a6d177edb9cf7fe/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b211ddaf20f7ebeec5c333448582c224a7c90a9d98826fbab82c0ddc11348e6", size = 32773 },
-    { url = "https://files.pythonhosted.org/packages/89/32/a22a281806e3ef21b72db16f948cad22ec68e4bdd384139291e00ff82fe2/google_crc32c-1.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:0f99eaa09a9a7e642a61e06742856eec8b19fc0037832e03f941fe7cf0c8e4db", size = 33475 },
-    { url = "https://files.pythonhosted.org/packages/b8/c5/002975aff514e57fc084ba155697a049b3f9b52225ec3bc0f542871dd524/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32d1da0d74ec5634a05f53ef7df18fc646666a25efaaca9fc7dcfd4caf1d98c3", size = 33243 },
-    { url = "https://files.pythonhosted.org/packages/61/cb/c585282a03a0cea70fcaa1bf55d5d702d0f2351094d663ec3be1c6c67c52/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e10554d4abc5238823112c2ad7e4560f96c7bf3820b202660373d769d9e6e4c9", size = 32870 },
-]
-
-[[package]]
-name = "google-genai"
-version = "1.15.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "google-auth" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "typing-extensions" },
-    { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/19/da5a085ce419c33b9e6ae308005efad9bfa1b10f59f449d075bba1f16a64/google_genai-1.15.0.tar.gz", hash = "sha256:118bb26960d6343cd64f1aeb5c2b02144a36ad06716d0d1eb1fa3e0904db51f1", size = 173452 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6f/e2/acc99d36fd439fb2e558c7aebd049329dbfc08a094faf17d847d393e2810/google_genai-1.15.0-py3-none-any.whl", hash = "sha256:6d7f149cc735038b680722bed495004720514c234e2a445ab2f27967955071dd", size = 171278 },
-]
-
-[[package]]
-name = "google-resumable-media"
-version = "2.7.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-crc32c" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/58/5a/0efdc02665dca14e0837b62c8a1a93132c264bd02054a15abb2218afe0ae/google_resumable_media-2.7.2.tar.gz", hash = "sha256:5280aed4629f2b60b847b0d42f9857fd4935c11af266744df33d8074cae92fe0", size = 2163099 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/35/b8d3baf8c46695858cb9d8835a53baa1eeb9906ddaf2f728a5f5b640fd1e/google_resumable_media-2.7.2-py2.py3-none-any.whl", hash = "sha256:3ce7551e9fe6d99e9a126101d2536612bb73486721951e9562fee0f90c6ababa", size = 81251 },
-]
-
-[[package]]
-name = "googleapis-common-protos"
-version = "1.70.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530 },
-]
-
-[package.optional-dependencies]
-grpc = [
-    { name = "grpcio" },
-]
-
-[[package]]
-name = "graphviz"
-version = "0.20.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/83/5a40d19b8347f017e417710907f824915fba411a9befd092e52746b63e9f/graphviz-0.20.3.zip", hash = "sha256:09d6bc81e6a9fa392e7ba52135a9d49f1ed62526f96499325930e87ca1b5925d", size = 256455 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/be/d59db2d1d52697c6adc9eacaf50e8965b6345cc143f671e1ed068818d5cf/graphviz-0.20.3-py3-none-any.whl", hash = "sha256:81f848f2904515d8cd359cc611faba817598d2feaac4027b266aa3eda7b3dde5", size = 47126 },
-]
-
-[[package]]
-name = "greenlet"
-version = "3.2.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/34/c1/a82edae11d46c0d83481aacaa1e578fea21d94a1ef400afd734d47ad95ad/greenlet-3.2.2.tar.gz", hash = "sha256:ad053d34421a2debba45aa3cc39acf454acbcd025b3fc1a9f8a0dee237abd485", size = 185797 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/30/97b49779fff8601af20972a62cc4af0c497c1504dfbb3e93be218e093f21/greenlet-3.2.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:3ab7194ee290302ca15449f601036007873028712e92ca15fc76597a0aeb4c59", size = 269150 },
-    { url = "https://files.pythonhosted.org/packages/21/30/877245def4220f684bc2e01df1c2e782c164e84b32e07373992f14a2d107/greenlet-3.2.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2dc5c43bb65ec3669452af0ab10729e8fdc17f87a1f2ad7ec65d4aaaefabf6bf", size = 637381 },
-    { url = "https://files.pythonhosted.org/packages/8e/16/adf937908e1f913856b5371c1d8bdaef5f58f251d714085abeea73ecc471/greenlet-3.2.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:decb0658ec19e5c1f519faa9a160c0fc85a41a7e6654b3ce1b44b939f8bf1325", size = 651427 },
-    { url = "https://files.pythonhosted.org/packages/ad/49/6d79f58fa695b618654adac64e56aff2eeb13344dc28259af8f505662bb1/greenlet-3.2.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6fadd183186db360b61cb34e81117a096bff91c072929cd1b529eb20dd46e6c5", size = 645795 },
-    { url = "https://files.pythonhosted.org/packages/5a/e6/28ed5cb929c6b2f001e96b1d0698c622976cd8f1e41fe7ebc047fa7c6dd4/greenlet-3.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1919cbdc1c53ef739c94cf2985056bcc0838c1f217b57647cbf4578576c63825", size = 648398 },
-    { url = "https://files.pythonhosted.org/packages/9d/70/b200194e25ae86bc57077f695b6cc47ee3118becf54130c5514456cf8dac/greenlet-3.2.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3885f85b61798f4192d544aac7b25a04ece5fe2704670b4ab73c2d2c14ab740d", size = 606795 },
-    { url = "https://files.pythonhosted.org/packages/f8/c8/ba1def67513a941154ed8f9477ae6e5a03f645be6b507d3930f72ed508d3/greenlet-3.2.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:85f3e248507125bf4af607a26fd6cb8578776197bd4b66e35229cdf5acf1dfbf", size = 1117976 },
-    { url = "https://files.pythonhosted.org/packages/c3/30/d0e88c1cfcc1b3331d63c2b54a0a3a4a950ef202fb8b92e772ca714a9221/greenlet-3.2.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1e76106b6fc55fa3d6fe1c527f95ee65e324a13b62e243f77b48317346559708", size = 1145509 },
-    { url = "https://files.pythonhosted.org/packages/90/2e/59d6491834b6e289051b252cf4776d16da51c7c6ca6a87ff97e3a50aa0cd/greenlet-3.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:fe46d4f8e94e637634d54477b0cfabcf93c53f29eedcbdeecaf2af32029b4421", size = 296023 },
-    { url = "https://files.pythonhosted.org/packages/65/66/8a73aace5a5335a1cba56d0da71b7bd93e450f17d372c5b7c5fa547557e9/greenlet-3.2.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba30e88607fb6990544d84caf3c706c4b48f629e18853fc6a646f82db9629418", size = 629911 },
-    { url = "https://files.pythonhosted.org/packages/48/08/c8b8ebac4e0c95dcc68ec99198842e7db53eda4ab3fb0a4e785690883991/greenlet-3.2.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:055916fafad3e3388d27dd68517478933a97edc2fc54ae79d3bec827de2c64c4", size = 635251 },
-    { url = "https://files.pythonhosted.org/packages/37/26/7db30868f73e86b9125264d2959acabea132b444b88185ba5c462cb8e571/greenlet-3.2.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2593283bf81ca37d27d110956b79e8723f9aa50c4bcdc29d3c0543d4743d2763", size = 632620 },
-    { url = "https://files.pythonhosted.org/packages/10/ec/718a3bd56249e729016b0b69bee4adea0dfccf6ca43d147ef3b21edbca16/greenlet-3.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89c69e9a10670eb7a66b8cef6354c24671ba241f46152dd3eed447f79c29fb5b", size = 628851 },
-    { url = "https://files.pythonhosted.org/packages/9b/9d/d1c79286a76bc62ccdc1387291464af16a4204ea717f24e77b0acd623b99/greenlet-3.2.2-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02a98600899ca1ca5d3a2590974c9e3ec259503b2d6ba6527605fcd74e08e207", size = 593718 },
-    { url = "https://files.pythonhosted.org/packages/cd/41/96ba2bf948f67b245784cd294b84e3d17933597dffd3acdb367a210d1949/greenlet-3.2.2-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:b50a8c5c162469c3209e5ec92ee4f95c8231b11db6a04db09bbe338176723bb8", size = 1105752 },
-    { url = "https://files.pythonhosted.org/packages/68/3b/3b97f9d33c1f2eb081759da62bd6162159db260f602f048bc2f36b4c453e/greenlet-3.2.2-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:45f9f4853fb4cc46783085261c9ec4706628f3b57de3e68bae03e8f8b3c0de51", size = 1125170 },
-    { url = "https://files.pythonhosted.org/packages/31/df/b7d17d66c8d0f578d2885a3d8f565e9e4725eacc9d3fdc946d0031c055c4/greenlet-3.2.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:9ea5231428af34226c05f927e16fc7f6fa5e39e3ad3cd24ffa48ba53a47f4240", size = 269899 },
-]
-
-[[package]]
-name = "grpc-google-iam-v1"
-version = "0.14.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos", extra = ["grpc"] },
-    { name = "grpcio" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/4e/8d0ca3b035e41fe0b3f31ebbb638356af720335e5a11154c330169b40777/grpc_google_iam_v1-0.14.2.tar.gz", hash = "sha256:b3e1fc387a1a329e41672197d0ace9de22c78dd7d215048c4c78712073f7bd20", size = 16259 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/6f/dd9b178aee7835b96c2e63715aba6516a9d50f6bebbd1cc1d32c82a2a6c3/grpc_google_iam_v1-0.14.2-py3-none-any.whl", hash = "sha256:a3171468459770907926d56a440b2bb643eec1d7ba215f48f3ecece42b4d8351", size = 19242 },
-]
-
-[[package]]
-name = "grpcio"
-version = "1.71.0"
+name = "annotated-types"
+version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1c/95/aa11fc09a85d91fbc7dd405dcb2a1e0256989d67bf89fa65ae24b3ba105a/grpcio-1.71.0.tar.gz", hash = "sha256:2b85f7820475ad3edec209d3d89a7909ada16caab05d3f2e08a7e8ae3200a55c", size = 12549828 }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/dd/b00cbb45400d06b26126dcfdbdb34bb6c4f28c3ebbd7aea8228679103ef6/grpcio-1.71.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:cebc1b34ba40a312ab480ccdb396ff3c529377a2fce72c45a741f7215bfe8379", size = 5184138 },
-    { url = "https://files.pythonhosted.org/packages/ed/0a/4651215983d590ef53aac40ba0e29dda941a02b097892c44fa3357e706e5/grpcio-1.71.0-cp313-cp313-macosx_10_14_universal2.whl", hash = "sha256:85da336e3649a3d2171e82f696b5cad2c6231fdd5bad52616476235681bee5b3", size = 11310747 },
-    { url = "https://files.pythonhosted.org/packages/57/a3/149615b247f321e13f60aa512d3509d4215173bdb982c9098d78484de216/grpcio-1.71.0-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:f9a412f55bb6e8f3bb000e020dbc1e709627dcb3a56f6431fa7076b4c1aab0db", size = 5653991 },
-    { url = "https://files.pythonhosted.org/packages/ca/56/29432a3e8d951b5e4e520a40cd93bebaa824a14033ea8e65b0ece1da6167/grpcio-1.71.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47be9584729534660416f6d2a3108aaeac1122f6b5bdbf9fd823e11fe6fbaa29", size = 6312781 },
-    { url = "https://files.pythonhosted.org/packages/a3/f8/286e81a62964ceb6ac10b10925261d4871a762d2a763fbf354115f9afc98/grpcio-1.71.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c9c80ac6091c916db81131d50926a93ab162a7e97e4428ffc186b6e80d6dda4", size = 5910479 },
-    { url = "https://files.pythonhosted.org/packages/35/67/d1febb49ec0f599b9e6d4d0d44c2d4afdbed9c3e80deb7587ec788fcf252/grpcio-1.71.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:789d5e2a3a15419374b7b45cd680b1e83bbc1e52b9086e49308e2c0b5bbae6e3", size = 6013262 },
-    { url = "https://files.pythonhosted.org/packages/a1/04/f9ceda11755f0104a075ad7163fc0d96e2e3a9fe25ef38adfc74c5790daf/grpcio-1.71.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:1be857615e26a86d7363e8a163fade914595c81fec962b3d514a4b1e8760467b", size = 6643356 },
-    { url = "https://files.pythonhosted.org/packages/fb/ce/236dbc3dc77cf9a9242adcf1f62538734ad64727fabf39e1346ad4bd5c75/grpcio-1.71.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a76d39b5fafd79ed604c4be0a869ec3581a172a707e2a8d7a4858cb05a5a7637", size = 6186564 },
-    { url = "https://files.pythonhosted.org/packages/10/fd/b3348fce9dd4280e221f513dd54024e765b21c348bc475516672da4218e9/grpcio-1.71.0-cp313-cp313-win32.whl", hash = "sha256:74258dce215cb1995083daa17b379a1a5a87d275387b7ffe137f1d5131e2cfbb", size = 3601890 },
-    { url = "https://files.pythonhosted.org/packages/be/f8/db5d5f3fc7e296166286c2a397836b8b042f7ad1e11028d82b061701f0f7/grpcio-1.71.0-cp313-cp313-win_amd64.whl", hash = "sha256:22c3bc8d488c039a199f7a003a38cb7635db6656fa96437a8accde8322ce2366", size = 4273308 },
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
 [[package]]
-name = "grpcio-status"
-version = "1.71.0"
+name = "anyio"
+version = "4.14.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "googleapis-common-protos" },
-    { name = "grpcio" },
-    { name = "protobuf" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d7/53/a911467bece076020456401f55a27415d2d70d3bc2c37af06b44ea41fc5c/grpcio_status-1.71.0.tar.gz", hash = "sha256:11405fed67b68f406b3f3c7c5ae5104a79d2d309666d10d61b152e91d28fb968", size = 13669 }
+sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ad/d6/31fbc43ff097d8c4c9fc3df741431b8018f67bf8dfbe6553a555f6e5f675/grpcio_status-1.71.0-py3-none-any.whl", hash = "sha256:843934ef8c09e3e858952887467f8256aac3910c55f077a359a65b2b3cde3e68", size = 14424 },
+    { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" },
 ]
 
 [[package]]
-name = "h11"
-version = "0.16.0"
+name = "async-timeout"
+version = "5.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
-]
-
-[[package]]
-name = "helloworld"
-version = "0.1.0"
-source = { editable = "examples/helloworld" }
-dependencies = [
-    { name = "a2a-sdk" },
-    { name = "click" },
-    { name = "dotenv" },
-    { name = "httpx" },
-    { name = "langchain-google-genai" },
-    { name = "langgraph" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "uvicorn" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "a2a-sdk", editable = "." },
-    { name = "click", specifier = ">=8.1.8" },
-    { name = "dotenv", specifier = ">=0.9.9" },
-    { name = "httpx", specifier = ">=0.28.1" },
-    { name = "langchain-google-genai", specifier = ">=2.1.4" },
-    { name = "langgraph", specifier = ">=0.4.1" },
-    { name = "pydantic", specifier = ">=2.11.4" },
-    { name = "python-dotenv", specifier = ">=1.1.0" },
-    { name = "uvicorn", specifier = ">=0.34.2" },
+    { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
 ]
 
 [[package]]
-name = "httpcore"
-version = "1.0.9"
+name = "asyncpg"
+version = "0.31.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
+    { name = "async-timeout", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cc/d18065ce2380d80b1bcce927c24a2642efd38918e33fd724bc4bca904877/asyncpg-0.31.0.tar.gz", hash = "sha256:c989386c83940bfbd787180f2b1519415e2d3d6277a70d9d0f0145ac73500735", size = 993667, upload-time = "2025-11-24T23:27:00.812Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
+    { url = "https://files.pythonhosted.org/packages/c3/d9/507c80bdac2e95e5a525644af94b03fa7f9a44596a84bd48a6e80f854f92/asyncpg-0.31.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:831712dd3cf117eec68575a9b50da711893fd63ebe277fc155ecae1c6c9f0f61", size = 644865, upload-time = "2025-11-24T23:25:23.527Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/03/f93b5e543f65c5f504e91405e8d21bb9e600548be95032951a754781a41d/asyncpg-0.31.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0b17c89312c2f4ccea222a3a6571f7df65d4ba2c0e803339bfc7bed46a96d3be", size = 639297, upload-time = "2025-11-24T23:25:25.192Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/de2177e57e03a06e697f6c1ddf2a9a7fcfdc236ce69966f54ffc830fd481/asyncpg-0.31.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3faa62f997db0c9add34504a68ac2c342cfee4d57a0c3062fcf0d86c7f9cb1e8", size = 2816679, upload-time = "2025-11-24T23:25:26.718Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/98/1a853f6870ac7ad48383a948c8ff3c85dc278066a4d69fc9af7d3d4b1106/asyncpg-0.31.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ea599d45c361dfbf398cb67da7fd052affa556a401482d3ff1ee99bd68808a1", size = 2867087, upload-time = "2025-11-24T23:25:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/11/29/7e76f2a51f2360a7c90d2cf6d0d9b210c8bb0ae342edebd16173611a55c2/asyncpg-0.31.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:795416369c3d284e1837461909f58418ad22b305f955e625a4b3a2521d80a5f3", size = 2747631, upload-time = "2025-11-24T23:25:30.154Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/3f/716e10cb57c4f388248db46555e9226901688fbfabd0afb85b5e1d65d5a7/asyncpg-0.31.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a8d758dac9d2e723e173d286ef5e574f0b350ec00e9186fce84d0fc5f6a8e6b8", size = 2855107, upload-time = "2025-11-24T23:25:31.888Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/ec/3ebae9dfb23a1bd3f68acfd4f795983b65b413291c0e2b0d982d6ae6c920/asyncpg-0.31.0-cp310-cp310-win32.whl", hash = "sha256:2d076d42eb583601179efa246c5d7ae44614b4144bc1c7a683ad1222814ed095", size = 521990, upload-time = "2025-11-24T23:25:33.402Z" },
+    { url = "https://files.pythonhosted.org/packages/20/b4/9fbb4b0af4e36d96a61d026dd37acab3cf521a70290a09640b215da5ab7c/asyncpg-0.31.0-cp310-cp310-win_amd64.whl", hash = "sha256:9ea33213ac044171f4cac23740bed9a3805abae10e7025314cfbd725ec670540", size = 581629, upload-time = "2025-11-24T23:25:34.846Z" },
+    { url = "https://files.pythonhosted.org/packages/08/17/cc02bc49bc350623d050fa139e34ea512cd6e020562f2a7312a7bcae4bc9/asyncpg-0.31.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eee690960e8ab85063ba93af2ce128c0f52fd655fdff9fdb1a28df01329f031d", size = 643159, upload-time = "2025-11-24T23:25:36.443Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/62/4ded7d400a7b651adf06f49ea8f73100cca07c6df012119594d1e3447aa6/asyncpg-0.31.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2657204552b75f8288de08ca60faf4a99a65deef3a71d1467454123205a88fab", size = 638157, upload-time = "2025-11-24T23:25:37.89Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5b/4179538a9a72166a0bf60ad783b1ef16efb7960e4d7b9afe9f77a5551680/asyncpg-0.31.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a429e842a3a4b4ea240ea52d7fe3f82d5149853249306f7ff166cb9948faa46c", size = 2918051, upload-time = "2025-11-24T23:25:39.461Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/35/c27719ae0536c5b6e61e4701391ffe435ef59539e9360959240d6e47c8c8/asyncpg-0.31.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0807be46c32c963ae40d329b3a686356e417f674c976c07fa49f1b30303f109", size = 2972640, upload-time = "2025-11-24T23:25:41.512Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f4/01ebb9207f29e645a64699b9ce0eefeff8e7a33494e1d29bb53736f7766b/asyncpg-0.31.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e5d5098f63beeae93512ee513d4c0c53dc12e9aa2b7a1af5a81cddf93fe4e4da", size = 2851050, upload-time = "2025-11-24T23:25:43.153Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f4/03ff1426acc87be0f4e8d40fa2bff5c3952bef0080062af9efc2212e3be8/asyncpg-0.31.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37fc6c00a814e18eef51833545d1891cac9aa69140598bb076b4cd29b3e010b9", size = 2962574, upload-time = "2025-11-24T23:25:44.942Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/39/cc788dfca3d4060f9d93e67be396ceec458dfc429e26139059e58c2c244d/asyncpg-0.31.0-cp311-cp311-win32.whl", hash = "sha256:5a4af56edf82a701aece93190cc4e094d2df7d33f6e915c222fb09efbb5afc24", size = 521076, upload-time = "2025-11-24T23:25:46.486Z" },
+    { url = "https://files.pythonhosted.org/packages/28/fc/735af5384c029eb7f1ca60ccb8fa95521dbdaeef788edf4cecfc604c3cab/asyncpg-0.31.0-cp311-cp311-win_amd64.whl", hash = "sha256:480c4befbdf079c14c9ca43c8c5e1fe8b6296c96f1f927158d4f1e750aacc047", size = 584980, upload-time = "2025-11-24T23:25:47.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/a6/59d0a146e61d20e18db7396583242e32e0f120693b67a8de43f1557033e2/asyncpg-0.31.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b44c31e1efc1c15188ef183f287c728e2046abb1d26af4d20858215d50d91fad", size = 662042, upload-time = "2025-11-24T23:25:49.578Z" },
+    { url = "https://files.pythonhosted.org/packages/36/01/ffaa189dcb63a2471720615e60185c3f6327716fdc0fc04334436fbb7c65/asyncpg-0.31.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0c89ccf741c067614c9b5fc7f1fc6f3b61ab05ae4aaa966e6fd6b93097c7d20d", size = 638504, upload-time = "2025-11-24T23:25:51.501Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/62/3f699ba45d8bd24c5d65392190d19656d74ff0185f42e19d0bbd973bb371/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:12b3b2e39dc5470abd5e98c8d3373e4b1d1234d9fbdedf538798b2c13c64460a", size = 3426241, upload-time = "2025-11-24T23:25:53.278Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d1/a867c2150f9c6e7af6462637f613ba67f78a314b00db220cd26ff559d532/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:aad7a33913fb8bcb5454313377cc330fbb19a0cd5faa7272407d8a0c4257b671", size = 3520321, upload-time = "2025-11-24T23:25:54.982Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1a/cce4c3f246805ecd285a3591222a2611141f1669d002163abef999b60f98/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3df118d94f46d85b2e434fd62c84cb66d5834d5a890725fe625f498e72e4d5ec", size = 3316685, upload-time = "2025-11-24T23:25:57.43Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ae/0fc961179e78cc579e138fad6eb580448ecae64908f95b8cb8ee2f241f67/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bd5b6efff3c17c3202d4b37189969acf8927438a238c6257f66be3c426beba20", size = 3471858, upload-time = "2025-11-24T23:25:59.636Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b2/b20e09670be031afa4cbfabd645caece7f85ec62d69c312239de568e058e/asyncpg-0.31.0-cp312-cp312-win32.whl", hash = "sha256:027eaa61361ec735926566f995d959ade4796f6a49d3bde17e5134b9964f9ba8", size = 527852, upload-time = "2025-11-24T23:26:01.084Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f0/f2ed1de154e15b107dc692262395b3c17fc34eafe2a78fc2115931561730/asyncpg-0.31.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d6bdcbc93d608a1158f17932de2321f68b1a967a13e014998db87a72ed3186", size = 597175, upload-time = "2025-11-24T23:26:02.564Z" },
+    { url = "https://files.pythonhosted.org/packages/95/11/97b5c2af72a5d0b9bc3fa30cd4b9ce22284a9a943a150fdc768763caf035/asyncpg-0.31.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c204fab1b91e08b0f47e90a75d1b3c62174dab21f670ad6c5d0f243a228f015b", size = 661111, upload-time = "2025-11-24T23:26:04.467Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/71/157d611c791a5e2d0423f09f027bd499935f0906e0c2a416ce712ba51ef3/asyncpg-0.31.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:54a64f91839ba59008eccf7aad2e93d6e3de688d796f35803235ea1c4898ae1e", size = 636928, upload-time = "2025-11-24T23:26:05.944Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/fc/9e3486fb2bbe69d4a867c0b76d68542650a7ff1574ca40e84c3111bb0c6e/asyncpg-0.31.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0e0822b1038dc7253b337b0f3f676cadc4ac31b126c5d42691c39691962e403", size = 3424067, upload-time = "2025-11-24T23:26:07.957Z" },
+    { url = "https://files.pythonhosted.org/packages/12/c6/8c9d076f73f07f995013c791e018a1cd5f31823c2a3187fc8581706aa00f/asyncpg-0.31.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bef056aa502ee34204c161c72ca1f3c274917596877f825968368b2c33f585f4", size = 3518156, upload-time = "2025-11-24T23:26:09.591Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3b/60683a0baf50fbc546499cfb53132cb6835b92b529a05f6a81471ab60d0c/asyncpg-0.31.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0bfbcc5b7ffcd9b75ab1558f00db2ae07db9c80637ad1b2469c43df79d7a5ae2", size = 3319636, upload-time = "2025-11-24T23:26:11.168Z" },
+    { url = "https://files.pythonhosted.org/packages/50/dc/8487df0f69bd398a61e1792b3cba0e47477f214eff085ba0efa7eac9ce87/asyncpg-0.31.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:22bc525ebbdc24d1261ecbf6f504998244d4e3be1721784b5f64664d61fbe602", size = 3472079, upload-time = "2025-11-24T23:26:13.164Z" },
+    { url = "https://files.pythonhosted.org/packages/13/a1/c5bbeeb8531c05c89135cb8b28575ac2fac618bcb60119ee9696c3faf71c/asyncpg-0.31.0-cp313-cp313-win32.whl", hash = "sha256:f890de5e1e4f7e14023619399a471ce4b71f5418cd67a51853b9910fdfa73696", size = 527606, upload-time = "2025-11-24T23:26:14.78Z" },
+    { url = "https://files.pythonhosted.org/packages/91/66/b25ccb84a246b470eb943b0107c07edcae51804912b824054b3413995a10/asyncpg-0.31.0-cp313-cp313-win_amd64.whl", hash = "sha256:dc5f2fa9916f292e5c5c8b2ac2813763bcd7f58e130055b4ad8a0531314201ab", size = 596569, upload-time = "2025-11-24T23:26:16.189Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/36/e9450d62e84a13aea6580c83a47a437f26c7ca6fa0f0fd40b6670793ea30/asyncpg-0.31.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f6b56b91bb0ffc328c4e3ed113136cddd9deefdf5f79ab448598b9772831df44", size = 660867, upload-time = "2025-11-24T23:26:17.631Z" },
+    { url = "https://files.pythonhosted.org/packages/82/4b/1d0a2b33b3102d210439338e1beea616a6122267c0df459ff0265cd5807a/asyncpg-0.31.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:334dec28cf20d7f5bb9e45b39546ddf247f8042a690bff9b9573d00086e69cb5", size = 638349, upload-time = "2025-11-24T23:26:19.689Z" },
+    { url = "https://files.pythonhosted.org/packages/41/aa/e7f7ac9a7974f08eff9183e392b2d62516f90412686532d27e196c0f0eeb/asyncpg-0.31.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98cc158c53f46de7bb677fd20c417e264fc02b36d901cc2a43bd6cb0dc6dbfd2", size = 3410428, upload-time = "2025-11-24T23:26:21.275Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/de/bf1b60de3dede5c2731e6788617a512bc0ebd9693eac297ee74086f101d7/asyncpg-0.31.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9322b563e2661a52e3cdbc93eed3be7748b289f792e0011cb2720d278b366ce2", size = 3471678, upload-time = "2025-11-24T23:26:23.627Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/fc3ade003e22d8bd53aaf8f75f4be48f0b460fa73738f0391b9c856a9147/asyncpg-0.31.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19857a358fc811d82227449b7ca40afb46e75b33eb8897240c3839dd8b744218", size = 3313505, upload-time = "2025-11-24T23:26:25.235Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e9/73eb8a6789e927816f4705291be21f2225687bfa97321e40cd23055e903a/asyncpg-0.31.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ba5f8886e850882ff2c2ace5732300e99193823e8107e2c53ef01c1ebfa1e85d", size = 3434744, upload-time = "2025-11-24T23:26:26.944Z" },
+    { url = "https://files.pythonhosted.org/packages/08/4b/f10b880534413c65c5b5862f79b8e81553a8f364e5238832ad4c0af71b7f/asyncpg-0.31.0-cp314-cp314-win32.whl", hash = "sha256:cea3a0b2a14f95834cee29432e4ddc399b95700eb1d51bbc5bfee8f31fa07b2b", size = 532251, upload-time = "2025-11-24T23:26:28.404Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/2d/7aa40750b7a19efa5d66e67fc06008ca0f27ba1bd082e457ad82f59aba49/asyncpg-0.31.0-cp314-cp314-win_amd64.whl", hash = "sha256:04d19392716af6b029411a0264d92093b6e5e8285ae97a39957b9a9c14ea72be", size = 604901, upload-time = "2025-11-24T23:26:30.34Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/fe/b9dfe349b83b9dee28cc42360d2c86b2cdce4cb551a2c2d27e156bcac84d/asyncpg-0.31.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bdb957706da132e982cc6856bb2f7b740603472b54c3ebc77fe60ea3e57e1bd2", size = 702280, upload-time = "2025-11-24T23:26:32Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/81/e6be6e37e560bd91e6c23ea8a6138a04fd057b08cf63d3c5055c98e81c1d/asyncpg-0.31.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6d11b198111a72f47154fa03b85799f9be63701e068b43f84ac25da0bda9cb31", size = 682931, upload-time = "2025-11-24T23:26:33.572Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/45/6009040da85a1648dd5bc75b3b0a062081c483e75a1a29041ae63a0bf0dc/asyncpg-0.31.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18c83b03bc0d1b23e6230f5bf8d4f217dc9bc08644ce0502a9d91dc9e634a9c7", size = 3581608, upload-time = "2025-11-24T23:26:35.638Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/06/2e3d4d7608b0b2b3adbee0d0bd6a2d29ca0fc4d8a78f8277df04e2d1fd7b/asyncpg-0.31.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e009abc333464ff18b8f6fd146addffd9aaf63e79aa3bb40ab7a4c332d0c5e9e", size = 3498738, upload-time = "2025-11-24T23:26:37.275Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/aa/7d75ede780033141c51d83577ea23236ba7d3a23593929b32b49db8ed36e/asyncpg-0.31.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3b1fbcb0e396a5ca435a8826a87e5c2c2cc0c8c68eb6fadf82168056b0e53a8c", size = 3401026, upload-time = "2025-11-24T23:26:39.423Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7a/15e37d45e7f7c94facc1e9148c0e455e8f33c08f0b8a0b1deb2c5171771b/asyncpg-0.31.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8df714dba348efcc162d2adf02d213e5fab1bd9f557e1305633e851a61814a7a", size = 3429426, upload-time = "2025-11-24T23:26:41.032Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d5/71437c5f6ae5f307828710efbe62163974e71237d5d46ebd2869ea052d10/asyncpg-0.31.0-cp314-cp314t-win32.whl", hash = "sha256:1b41f1afb1033f2b44f3234993b15096ddc9cd71b21a42dbd87fc6a57b43d65d", size = 614495, upload-time = "2025-11-24T23:26:42.659Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/d7/8fb3044eaef08a310acfe23dae9a8e2e07d305edc29a53497e52bc76eca7/asyncpg-0.31.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bd4107bb7cdd0e9e65fae66a62afd3a249663b844fa34d479f6d5b3bef9c04c3", size = 706062, upload-time = "2025-11-24T23:26:44.086Z" },
 ]
 
 [[package]]
-name = "httplib2"
-version = "0.22.0"
+name = "attrs"
+version = "26.1.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyparsing" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/ad/2371116b22d616c194aa25ec410c9c6c37f23599dcd590502b74db197584/httplib2-0.22.0.tar.gz", hash = "sha256:d7a10bc5ef5ab08322488bde8c726eeee5c8618723fdb399597ec58f3d82df81", size = 351116 }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/6c/d2fbdaaa5959339d53ba38e94c123e4e84b8fbc4b84beb0e70d7c1608486/httplib2-0.22.0-py3-none-any.whl", hash = "sha256:14ae0a53c1ba8f3d37e9e27cf37eabb0fb9980f435ba405d546948b009dd64dc", size = 96854 },
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
 ]
 
 [[package]]
-name = "httpx"
-version = "0.28.1"
+name = "backports-asyncio-runner"
+version = "1.2.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "certifi" },
-    { name = "httpcore" },
-    { name = "idna" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893, upload-time = "2025-07-02T02:27:15.685Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
+    { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" },
 ]
 
 [[package]]
-name = "httpx-sse"
-version = "0.4.0"
+name = "certifi"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4c/60/8f4281fa9bbf3c8034fd54c0e7412e66edbab6bc74c4996bd616f8d0406e/httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721", size = 12624 }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/9b/a181f281f65d776426002f330c31849b86b31fc9d848db62e16f03ff739f/httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f", size = 7819 },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
-name = "idna"
-version = "3.10"
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" },
+    { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" },
+    { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" },
+    { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" },
+    { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" },
+    { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" },
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
 ]
 
 [[package]]
-name = "importlib-metadata"
-version = "8.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 },
+name = "charset-normalizer"
+version = "3.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/60/e3bec1881450851b087e301bedc3daa9377a4d45f1c26aa90b0b235e38aa/charset_normalizer-3.4.6.tar.gz", hash = "sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6", size = 143363, upload-time = "2026-03-15T18:53:25.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/8c/2c56124c6dc53a774d435f985b5973bc592f42d437be58c0c92d65ae7296/charset_normalizer-3.4.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2e1d8ca8611099001949d1cdfaefc510cf0f212484fe7c565f735b68c78c3c95", size = 298751, upload-time = "2026-03-15T18:50:00.003Z" },
+    { url = "https://files.pythonhosted.org/packages/86/2a/2a7db6b314b966a3bcad8c731c0719c60b931b931de7ae9f34b2839289ee/charset_normalizer-3.4.6-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e25369dc110d58ddf29b949377a93e0716d72a24f62bad72b2b39f155949c1fd", size = 200027, upload-time = "2026-03-15T18:50:01.702Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f2/0fe775c74ae25e2a3b07b01538fc162737b3e3f795bada3bc26f4d4d495c/charset_normalizer-3.4.6-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:259695e2ccc253feb2a016303543d691825e920917e31f894ca1a687982b1de4", size = 220741, upload-time = "2026-03-15T18:50:03.194Z" },
+    { url = "https://files.pythonhosted.org/packages/10/98/8085596e41f00b27dd6aa1e68413d1ddda7e605f34dd546833c61fddd709/charset_normalizer-3.4.6-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dda86aba335c902b6149a02a55b38e96287157e609200811837678214ba2b1db", size = 215802, upload-time = "2026-03-15T18:50:05.859Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ce/865e4e09b041bad659d682bbd98b47fb490b8e124f9398c9448065f64fee/charset_normalizer-3.4.6-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51fb3c322c81d20567019778cb5a4a6f2dc1c200b886bc0d636238e364848c89", size = 207908, upload-time = "2026-03-15T18:50:07.676Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/54/8c757f1f7349262898c2f169e0d562b39dcb977503f18fdf0814e923db78/charset_normalizer-3.4.6-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:4482481cb0572180b6fd976a4d5c72a30263e98564da68b86ec91f0fe35e8565", size = 194357, upload-time = "2026-03-15T18:50:09.327Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/29/e88f2fac9218907fc7a70722b393d1bbe8334c61fe9c46640dba349b6e66/charset_normalizer-3.4.6-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:39f5068d35621da2881271e5c3205125cc456f54e9030d3f723288c873a71bf9", size = 205610, upload-time = "2026-03-15T18:50:10.732Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/c5/21d7bb0cb415287178450171d130bed9d664211fdd59731ed2c34267b07d/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8bea55c4eef25b0b19a0337dc4e3f9a15b00d569c77211fa8cde38684f234fb7", size = 203512, upload-time = "2026-03-15T18:50:12.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/be/ce52f3c7fdb35cc987ad38a53ebcef52eec498f4fb6c66ecfe62cfe57ba2/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f0cdaecd4c953bfae0b6bb64910aaaca5a424ad9c72d85cb88417bb9814f7550", size = 195398, upload-time = "2026-03-15T18:50:14.236Z" },
+    { url = "https://files.pythonhosted.org/packages/81/a0/3ab5dd39d4859a3555e5dadfc8a9fa7f8352f8c183d1a65c90264517da0e/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:150b8ce8e830eb7ccb029ec9ca36022f756986aaaa7956aad6d9ec90089338c0", size = 221772, upload-time = "2026-03-15T18:50:15.581Z" },
+    { url = "https://files.pythonhosted.org/packages/04/6e/6a4e41a97ba6b2fa87f849c41e4d229449a586be85053c4d90135fe82d26/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:e68c14b04827dd76dcbd1aeea9e604e3e4b78322d8faf2f8132c7138efa340a8", size = 205759, upload-time = "2026-03-15T18:50:17.047Z" },
+    { url = "https://files.pythonhosted.org/packages/db/3b/34a712a5ee64a6957bf355b01dc17b12de457638d436fdb05d01e463cd1c/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3778fd7d7cd04ae8f54651f4a7a0bd6e39a0cf20f801720a4c21d80e9b7ad6b0", size = 216938, upload-time = "2026-03-15T18:50:18.44Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/5bd1e12da9ab18790af05c61aafd01a60f489778179b621ac2a305243c62/charset_normalizer-3.4.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dad6e0f2e481fffdcf776d10ebee25e0ef89f16d691f1e5dee4b586375fdc64b", size = 210138, upload-time = "2026-03-15T18:50:19.852Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/8e/3cb9e2d998ff6b21c0a1860343cb7b83eba9cdb66b91410e18fc4969d6ab/charset_normalizer-3.4.6-cp310-cp310-win32.whl", hash = "sha256:74a2e659c7ecbc73562e2a15e05039f1e22c75b7c7618b4b574a3ea9118d1557", size = 144137, upload-time = "2026-03-15T18:50:21.505Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/8f/78f5489ffadb0db3eb7aff53d31c24531d33eb545f0c6f6567c25f49a5ff/charset_normalizer-3.4.6-cp310-cp310-win_amd64.whl", hash = "sha256:aa9cccf4a44b9b62d8ba8b4dd06c649ba683e4bf04eea606d2e94cfc2d6ff4d6", size = 154244, upload-time = "2026-03-15T18:50:22.81Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/74/e472659dffb0cadb2f411282d2d76c60da1fc94076d7fffed4ae8a93ec01/charset_normalizer-3.4.6-cp310-cp310-win_arm64.whl", hash = "sha256:e985a16ff513596f217cee86c21371b8cd011c0f6f056d0920aa2d926c544058", size = 143312, upload-time = "2026-03-15T18:50:24.074Z" },
+    { url = "https://files.pythonhosted.org/packages/62/28/ff6f234e628a2de61c458be2779cb182bc03f6eec12200d4a525bbfc9741/charset_normalizer-3.4.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:82060f995ab5003a2d6e0f4ad29065b7672b6593c8c63559beefe5b443242c3e", size = 293582, upload-time = "2026-03-15T18:50:25.454Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b7/b1a117e5385cbdb3205f6055403c2a2a220c5ea80b8716c324eaf75c5c95/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60c74963d8350241a79cb8feea80e54d518f72c26db618862a8f53e5023deaf9", size = 197240, upload-time = "2026-03-15T18:50:27.196Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5f/2574f0f09f3c3bc1b2f992e20bce6546cb1f17e111c5be07308dc5427956/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6e4333fb15c83f7d1482a76d45a0818897b3d33f00efd215528ff7c51b8e35d", size = 217363, upload-time = "2026-03-15T18:50:28.601Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d1/0ae20ad77bc949ddd39b51bf383b6ca932f2916074c95cad34ae465ab71f/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bc72863f4d9aba2e8fd9085e63548a324ba706d2ea2c83b260da08a59b9482de", size = 212994, upload-time = "2026-03-15T18:50:30.102Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ac/3233d262a310c1b12633536a07cde5ddd16985e6e7e238e9f3f9423d8eb9/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cc4fc6c196d6a8b76629a70ddfcd4635a6898756e2d9cac5565cf0654605d73", size = 204697, upload-time = "2026-03-15T18:50:31.654Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3c/8a18fc411f085b82303cfb7154eed5bd49c77035eb7608d049468b53f87c/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:0c173ce3a681f309f31b87125fecec7a5d1347261ea11ebbb856fa6006b23c8c", size = 191673, upload-time = "2026-03-15T18:50:33.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/a7/11cfe61d6c5c5c7438d6ba40919d0306ed83c9ab957f3d4da2277ff67836/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c907cdc8109f6c619e6254212e794d6548373cc40e1ec75e6e3823d9135d29cc", size = 201120, upload-time = "2026-03-15T18:50:35.105Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/10/cf491fa1abd47c02f69687046b896c950b92b6cd7337a27e6548adbec8e4/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:404a1e552cf5b675a87f0651f8b79f5f1e6fd100ee88dc612f89aa16abd4486f", size = 200911, upload-time = "2026-03-15T18:50:36.819Z" },
+    { url = "https://files.pythonhosted.org/packages/28/70/039796160b48b18ed466fde0af84c1b090c4e288fae26cd674ad04a2d703/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e3c701e954abf6fc03a49f7c579cc80c2c6cc52525340ca3186c41d3f33482ef", size = 192516, upload-time = "2026-03-15T18:50:38.228Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/34/c56f3223393d6ff3124b9e78f7de738047c2d6bc40a4f16ac0c9d7a1cb3c/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7a6967aaf043bceabab5412ed6bd6bd26603dae84d5cb75bf8d9a74a4959d398", size = 218795, upload-time = "2026-03-15T18:50:39.664Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/3b/ce2d4f86c5282191a041fdc5a4ce18f1c6bd40a5bd1f74cf8625f08d51c1/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5feb91325bbceade6afab43eb3b508c63ee53579fe896c77137ded51c6b6958e", size = 201833, upload-time = "2026-03-15T18:50:41.552Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/9b/b6a9f76b0fd7c5b5ec58b228ff7e85095370282150f0bd50b3126f5506d6/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f820f24b09e3e779fe84c3c456cb4108a7aa639b0d1f02c28046e11bfcd088ed", size = 213920, upload-time = "2026-03-15T18:50:43.33Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/98/7bc23513a33d8172365ed30ee3a3b3fe1ece14a395e5fc94129541fc6003/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b35b200d6a71b9839a46b9b7fff66b6638bb52fc9658aa58796b0326595d3021", size = 206951, upload-time = "2026-03-15T18:50:44.789Z" },
+    { url = "https://files.pythonhosted.org/packages/32/73/c0b86f3d1458468e11aec870e6b3feac931facbe105a894b552b0e518e79/charset_normalizer-3.4.6-cp311-cp311-win32.whl", hash = "sha256:9ca4c0b502ab399ef89248a2c84c54954f77a070f28e546a85e91da627d1301e", size = 143703, upload-time = "2026-03-15T18:50:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e3/76f2facfe8eddee0bbd38d2594e709033338eae44ebf1738bcefe0a06185/charset_normalizer-3.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:a9e68c9d88823b274cf1e72f28cb5dc89c990edf430b0bfd3e2fb0785bfeabf4", size = 153857, upload-time = "2026-03-15T18:50:47.563Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/dc/9abe19c9b27e6cd3636036b9d1b387b78c40dedbf0b47f9366737684b4b0/charset_normalizer-3.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:97d0235baafca5f2b09cf332cc275f021e694e8362c6bb9c96fc9a0eb74fc316", size = 142751, upload-time = "2026-03-15T18:50:49.234Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/62/c0815c992c9545347aeea7859b50dc9044d147e2e7278329c6e02ac9a616/charset_normalizer-3.4.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab", size = 295154, upload-time = "2026-03-15T18:50:50.88Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21", size = 199191, upload-time = "2026-03-15T18:50:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/92/9934d1bbd69f7f398b38c5dae1cbf9cc672e7c34a4adf7b17c0a9c17d15d/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2", size = 218674, upload-time = "2026-03-15T18:50:54.102Z" },
+    { url = "https://files.pythonhosted.org/packages/af/90/25f6ab406659286be929fd89ab0e78e38aa183fc374e03aa3c12d730af8a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f1ce721c8a7dfec21fcbdfe04e8f68174183cf4e8188e0645e92aa23985c57ff", size = 215259, upload-time = "2026-03-15T18:50:55.616Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ef/79a463eb0fff7f96afa04c1d4c51f8fc85426f918db467854bfb6a569ce3/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e28d62a8fc7a1fa411c43bd65e346f3bce9716dc51b897fbe930c5987b402d5", size = 207276, upload-time = "2026-03-15T18:50:57.054Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/72/d0426afec4b71dc159fa6b4e68f868cd5a3ecd918fec5813a15d292a7d10/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:530d548084c4a9f7a16ed4a294d459b4f229db50df689bfe92027452452943a0", size = 195161, upload-time = "2026-03-15T18:50:58.686Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/c82b06a68bfcb6ce55e508225d210c7e6a4ea122bfc0748892f3dc4e8e11/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30f445ae60aad5e1f8bdbb3108e39f6fbc09f4ea16c815c66578878325f8f15a", size = 203452, upload-time = "2026-03-15T18:51:00.196Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/0c25979b92f8adafdbb946160348d8d44aa60ce99afdc27df524379875cb/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ac2393c73378fea4e52aa56285a3d64be50f1a12395afef9cce47772f60334c2", size = 202272, upload-time = "2026-03-15T18:51:01.703Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/3d/7fea3e8fe84136bebbac715dd1221cc25c173c57a699c030ab9b8900cbb7/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:90ca27cd8da8118b18a52d5f547859cc1f8354a00cd1e8e5120df3e30d6279e5", size = 195622, upload-time = "2026-03-15T18:51:03.526Z" },
+    { url = "https://files.pythonhosted.org/packages/57/8a/d6f7fd5cb96c58ef2f681424fbca01264461336d2a7fc875e4446b1f1346/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e5a94886bedca0f9b78fecd6afb6629142fd2605aa70a125d49f4edc6037ee6", size = 220056, upload-time = "2026-03-15T18:51:05.269Z" },
+    { url = "https://files.pythonhosted.org/packages/16/50/478cdda782c8c9c3fb5da3cc72dd7f331f031e7f1363a893cdd6ca0f8de0/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:695f5c2823691a25f17bc5d5ffe79fa90972cc34b002ac6c843bb8a1720e950d", size = 203751, upload-time = "2026-03-15T18:51:06.858Z" },
+    { url = "https://files.pythonhosted.org/packages/75/fc/cc2fcac943939c8e4d8791abfa139f685e5150cae9f94b60f12520feaa9b/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:231d4da14bcd9301310faf492051bee27df11f2bc7549bc0bb41fef11b82daa2", size = 216563, upload-time = "2026-03-15T18:51:08.564Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b7/a4add1d9a5f68f3d037261aecca83abdb0ab15960a3591d340e829b37298/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a056d1ad2633548ca18ffa2f85c202cfb48b68615129143915b8dc72a806a923", size = 209265, upload-time = "2026-03-15T18:51:10.312Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/18/c094561b5d64a24277707698e54b7f67bd17a4f857bbfbb1072bba07c8bf/charset_normalizer-3.4.6-cp312-cp312-win32.whl", hash = "sha256:c2274ca724536f173122f36c98ce188fd24ce3dad886ec2b7af859518ce008a4", size = 144229, upload-time = "2026-03-15T18:51:11.694Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/20/0567efb3a8fd481b8f34f739ebddc098ed062a59fed41a8d193a61939e8f/charset_normalizer-3.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:c8ae56368f8cc97c7e40a7ee18e1cedaf8e780cd8bc5ed5ac8b81f238614facb", size = 154277, upload-time = "2026-03-15T18:51:13.004Z" },
+    { url = "https://files.pythonhosted.org/packages/15/57/28d79b44b51933119e21f65479d0864a8d5893e494cf5daab15df0247c17/charset_normalizer-3.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:899d28f422116b08be5118ef350c292b36fc15ec2daeb9ea987c89281c7bb5c4", size = 142817, upload-time = "2026-03-15T18:51:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/1d/4fdabeef4e231153b6ed7567602f3b68265ec4e5b76d6024cf647d43d981/charset_normalizer-3.4.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:11afb56037cbc4b1555a34dd69151e8e069bee82e613a73bef6e714ce733585f", size = 294823, upload-time = "2026-03-15T18:51:15.755Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/20e809b89c69d37be748d98e84dce6820bf663cf19cf6b942c951a3e8f41/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:423fb7e748a08f854a08a222b983f4df1912b1daedce51a72bd24fe8f26a1843", size = 198527, upload-time = "2026-03-15T18:51:17.177Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/4f8d27527d59c039dce6f7622593cdcd3d70a8504d87d09eb11e9fdc6062/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d73beaac5e90173ac3deb9928a74763a6d230f494e4bfb422c217a0ad8e629bf", size = 218388, upload-time = "2026-03-15T18:51:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/4770ccb3e491a9bacf1c46cc8b812214fe367c86a96353ccc6daf87b01ec/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d60377dce4511655582e300dc1e5a5f24ba0cb229005a1d5c8d0cb72bb758ab8", size = 214563, upload-time = "2026-03-15T18:51:20.374Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/58/a199d245894b12db0b957d627516c78e055adc3a0d978bc7f65ddaf7c399/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:530e8cebeea0d76bdcf93357aa5e41336f48c3dc709ac52da2bb167c5b8271d9", size = 206587, upload-time = "2026-03-15T18:51:21.807Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/70/3def227f1ec56f5c69dfc8392b8bd63b11a18ca8178d9211d7cc5e5e4f27/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:a26611d9987b230566f24a0a125f17fe0de6a6aff9f25c9f564aaa2721a5fb88", size = 194724, upload-time = "2026-03-15T18:51:23.508Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ab/9318352e220c05efd31c2779a23b50969dc94b985a2efa643ed9077bfca5/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34315ff4fc374b285ad7f4a0bf7dcbfe769e1b104230d40f49f700d4ab6bbd84", size = 202956, upload-time = "2026-03-15T18:51:25.239Z" },
+    { url = "https://files.pythonhosted.org/packages/75/13/f3550a3ac25b70f87ac98c40d3199a8503676c2f1620efbf8d42095cfc40/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ddd609f9e1af8c7bd6e2aca279c931aefecd148a14402d4e368f3171769fd", size = 201923, upload-time = "2026-03-15T18:51:26.682Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/db/c5c643b912740b45e8eec21de1bbab8e7fc085944d37e1e709d3dcd9d72f/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:80d0a5615143c0b3225e5e3ef22c8d5d51f3f72ce0ea6fb84c943546c7b25b6c", size = 195366, upload-time = "2026-03-15T18:51:28.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/67/3b1c62744f9b2448443e0eb160d8b001c849ec3fef591e012eda6484787c/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:92734d4d8d187a354a556626c221cd1a892a4e0802ccb2af432a1d85ec012194", size = 219752, upload-time = "2026-03-15T18:51:29.556Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/98/32ffbaf7f0366ffb0445930b87d103f6b406bc2c271563644bde8a2b1093/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:613f19aa6e082cf96e17e3ffd89383343d0d589abda756b7764cf78361fd41dc", size = 203296, upload-time = "2026-03-15T18:51:30.921Z" },
+    { url = "https://files.pythonhosted.org/packages/41/12/5d308c1bbe60cabb0c5ef511574a647067e2a1f631bc8634fcafaccd8293/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2b1a63e8224e401cafe7739f77efd3f9e7f5f2026bda4aead8e59afab537784f", size = 215956, upload-time = "2026-03-15T18:51:32.399Z" },
+    { url = "https://files.pythonhosted.org/packages/53/e9/5f85f6c5e20669dbe56b165c67b0260547dea97dba7e187938833d791687/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cceb5473417d28edd20c6c984ab6fee6c6267d38d906823ebfe20b03d607dc2", size = 208652, upload-time = "2026-03-15T18:51:34.214Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/11/897052ea6af56df3eef3ca94edafee410ca699ca0c7b87960ad19932c55e/charset_normalizer-3.4.6-cp313-cp313-win32.whl", hash = "sha256:d7de2637729c67d67cf87614b566626057e95c303bc0a55ffe391f5205e7003d", size = 143940, upload-time = "2026-03-15T18:51:36.15Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5c/724b6b363603e419829f561c854b87ed7c7e31231a7908708ac086cdf3e2/charset_normalizer-3.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:572d7c822caf521f0525ba1bce1a622a0b85cf47ffbdae6c9c19e3b5ac3c4389", size = 154101, upload-time = "2026-03-15T18:51:37.876Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a5/7abf15b4c0968e47020f9ca0935fb3274deb87cb288cd187cad92e8cdffd/charset_normalizer-3.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a4474d924a47185a06411e0064b803c68be044be2d60e50e8bddcc2649957c1f", size = 143109, upload-time = "2026-03-15T18:51:39.565Z" },
+    { url = "https://files.pythonhosted.org/packages/25/6f/ffe1e1259f384594063ea1869bfb6be5cdb8bc81020fc36c3636bc8302a1/charset_normalizer-3.4.6-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9cc6e6d9e571d2f863fa77700701dae73ed5f78881efc8b3f9a4398772ff53e8", size = 294458, upload-time = "2026-03-15T18:51:41.134Z" },
+    { url = "https://files.pythonhosted.org/packages/56/60/09bb6c13a8c1016c2ed5c6a6488e4ffef506461aa5161662bd7636936fb1/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5960d965e67165d75b7c7ffc60a83ec5abfc5c11b764ec13ea54fbef8b4421", size = 199277, upload-time = "2026-03-15T18:51:42.953Z" },
+    { url = "https://files.pythonhosted.org/packages/00/50/dcfbb72a5138bbefdc3332e8d81a23494bf67998b4b100703fd15fa52d81/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b3694e3f87f8ac7ce279d4355645b3c878d24d1424581b46282f24b92f5a4ae2", size = 218758, upload-time = "2026-03-15T18:51:44.339Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/d79a9a191bb75f5aa81f3aaaa387ef29ce7cb7a9e5074ba8ea095cc073c2/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d11595abf8dd942a77883a39d81433739b287b6aa71620f15164f8096221b30", size = 215299, upload-time = "2026-03-15T18:51:45.871Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7e/bc8911719f7084f72fd545f647601ea3532363927f807d296a8c88a62c0d/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7bda6eebafd42133efdca535b04ccb338ab29467b3f7bf79569883676fc628db", size = 206811, upload-time = "2026-03-15T18:51:47.308Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/40/c430b969d41dda0c465aa36cc7c2c068afb67177bef50905ac371b28ccc7/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:bbc8c8650c6e51041ad1be191742b8b421d05bbd3410f43fa2a00c8db87678e8", size = 193706, upload-time = "2026-03-15T18:51:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/48/15/e35e0590af254f7df984de1323640ef375df5761f615b6225ba8deb9799a/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:22c6f0c2fbc31e76c3b8a86fba1a56eda6166e238c29cdd3d14befdb4a4e4815", size = 202706, upload-time = "2026-03-15T18:51:50.257Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/bd/f736f7b9cc5e93a18b794a50346bb16fbfd6b37f99e8f306f7951d27c17c/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7edbed096e4a4798710ed6bc75dcaa2a21b68b6c356553ac4823c3658d53743a", size = 202497, upload-time = "2026-03-15T18:51:52.012Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ba/2cc9e3e7dfdf7760a6ed8da7446d22536f3d0ce114ac63dee2a5a3599e62/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7f9019c9cb613f084481bd6a100b12e1547cf2efe362d873c2e31e4035a6fa43", size = 193511, upload-time = "2026-03-15T18:51:53.723Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/cb/5be49b5f776e5613be07298c80e1b02a2d900f7a7de807230595c85a8b2e/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:58c948d0d086229efc484fe2f30c2d382c86720f55cd9bc33591774348ad44e0", size = 220133, upload-time = "2026-03-15T18:51:55.333Z" },
+    { url = "https://files.pythonhosted.org/packages/83/43/99f1b5dad345accb322c80c7821071554f791a95ee50c1c90041c157ae99/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:419a9d91bd238052642a51938af8ac05da5b3343becde08d5cdeab9046df9ee1", size = 203035, upload-time = "2026-03-15T18:51:56.736Z" },
+    { url = "https://files.pythonhosted.org/packages/87/9a/62c2cb6a531483b55dddff1a68b3d891a8b498f3ca555fbcf2978e804d9d/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5273b9f0b5835ff0350c0828faea623c68bfa65b792720c453e22b25cc72930f", size = 216321, upload-time = "2026-03-15T18:51:58.17Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/79/94a010ff81e3aec7c293eb82c28f930918e517bc144c9906a060844462eb/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0e901eb1049fdb80f5bd11ed5ea1e498ec423102f7a9b9e4645d5b8204ff2815", size = 208973, upload-time = "2026-03-15T18:51:59.998Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/57/4ecff6d4ec8585342f0c71bc03efaa99cb7468f7c91a57b105bcd561cea8/charset_normalizer-3.4.6-cp314-cp314-win32.whl", hash = "sha256:b4ff1d35e8c5bd078be89349b6f3a845128e685e751b6ea1169cf2160b344c4d", size = 144610, upload-time = "2026-03-15T18:52:02.213Z" },
+    { url = "https://files.pythonhosted.org/packages/80/94/8434a02d9d7f168c25767c64671fead8d599744a05d6a6c877144c754246/charset_normalizer-3.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:74119174722c4349af9708993118581686f343adc1c8c9c007d59be90d077f3f", size = 154962, upload-time = "2026-03-15T18:52:03.658Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4c/48f2cdbfd923026503dfd67ccea45c94fd8fe988d9056b468579c66ed62b/charset_normalizer-3.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:e5bcc1a1ae744e0bb59641171ae53743760130600da8db48cbb6e4918e186e4e", size = 143595, upload-time = "2026-03-15T18:52:05.123Z" },
+    { url = "https://files.pythonhosted.org/packages/31/93/8878be7569f87b14f1d52032946131bcb6ebbd8af3e20446bc04053dc3f1/charset_normalizer-3.4.6-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ad8faf8df23f0378c6d527d8b0b15ea4a2e23c89376877c598c4870d1b2c7866", size = 314828, upload-time = "2026-03-15T18:52:06.831Z" },
+    { url = "https://files.pythonhosted.org/packages/06/b6/fae511ca98aac69ecc35cde828b0a3d146325dd03d99655ad38fc2cc3293/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ea69428fa1b49573eef0cc44a1d43bebd45ad0c611eb7d7eac760c7ae771bc", size = 208138, upload-time = "2026-03-15T18:52:08.239Z" },
+    { url = "https://files.pythonhosted.org/packages/54/57/64caf6e1bf07274a1e0b7c160a55ee9e8c9ec32c46846ce59b9c333f7008/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:06a7e86163334edfc5d20fe104db92fcd666e5a5df0977cb5680a506fe26cc8e", size = 224679, upload-time = "2026-03-15T18:52:10.043Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cb/9ff5a25b9273ef160861b41f6937f86fae18b0792fe0a8e75e06acb08f1d/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e1f6e2f00a6b8edb562826e4632e26d063ac10307e80f7461f7de3ad8ef3f077", size = 223475, upload-time = "2026-03-15T18:52:11.854Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/97/440635fc093b8d7347502a377031f9605a1039c958f3cd18dcacffb37743/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b52c68d64c1878818687a473a10547b3292e82b6f6fe483808fb1468e2f52f", size = 215230, upload-time = "2026-03-15T18:52:13.325Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/24/afff630feb571a13f07c8539fbb502d2ab494019492aaffc78ef41f1d1d0/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:7504e9b7dc05f99a9bbb4525c67a2c155073b44d720470a148b34166a69c054e", size = 199045, upload-time = "2026-03-15T18:52:14.752Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/17/d1399ecdaf7e0498c327433e7eefdd862b41236a7e484355b8e0e5ebd64b/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:172985e4ff804a7ad08eebec0a1640ece87ba5041d565fff23c8f99c1f389484", size = 211658, upload-time = "2026-03-15T18:52:16.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/38/16baa0affb957b3d880e5ac2144caf3f9d7de7bc4a91842e447fbb5e8b67/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4be9f4830ba8741527693848403e2c457c16e499100963ec711b1c6f2049b7c7", size = 210769, upload-time = "2026-03-15T18:52:17.782Z" },
+    { url = "https://files.pythonhosted.org/packages/05/34/c531bc6ac4c21da9ddfddb3107be2287188b3ea4b53b70fc58f2a77ac8d8/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:79090741d842f564b1b2827c0b82d846405b744d31e84f18d7a7b41c20e473ff", size = 201328, upload-time = "2026-03-15T18:52:19.553Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/73/a5a1e9ca5f234519c1953608a03fe109c306b97fdfb25f09182babad51a7/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87725cfb1a4f1f8c2fc9890ae2f42094120f4b44db9360be5d99a4c6b0e03a9e", size = 225302, upload-time = "2026-03-15T18:52:21.043Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/f6/cd782923d112d296294dea4bcc7af5a7ae0f86ab79f8fefbda5526b6cfc0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fcce033e4021347d80ed9c66dcf1e7b1546319834b74445f561d2e2221de5659", size = 211127, upload-time = "2026-03-15T18:52:22.491Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c5/0b6898950627af7d6103a449b22320372c24c6feda91aa24e201a478d161/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ca0276464d148c72defa8bb4390cce01b4a0e425f3b50d1435aa6d7a18107602", size = 222840, upload-time = "2026-03-15T18:52:24.113Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/25/c4bba773bef442cbdc06111d40daa3de5050a676fa26e85090fc54dd12f0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:197c1a244a274bb016dd8b79204850144ef77fe81c5b797dc389327adb552407", size = 216890, upload-time = "2026-03-15T18:52:25.541Z" },
+    { url = "https://files.pythonhosted.org/packages/35/1a/05dacadb0978da72ee287b0143097db12f2e7e8d3ffc4647da07a383b0b7/charset_normalizer-3.4.6-cp314-cp314t-win32.whl", hash = "sha256:2a24157fa36980478dd1770b585c0f30d19e18f4fb0c47c13aa568f871718579", size = 155379, upload-time = "2026-03-15T18:52:27.05Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/d269d834cb3a76291651256f3b9a5945e81d0a49ab9f4a498964e83c0416/charset_normalizer-3.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:cd5e2801c89992ed8c0a3f0293ae83c159a60d9a5d685005383ef4caca77f2c4", size = 169043, upload-time = "2026-03-15T18:52:28.502Z" },
+    { url = "https://files.pythonhosted.org/packages/23/06/28b29fba521a37a8932c6a84192175c34d49f84a6d4773fa63d05f9aff22/charset_normalizer-3.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:47955475ac79cc504ef2704b192364e51d0d473ad452caedd0002605f780101c", size = 148523, upload-time = "2026-03-15T18:52:29.956Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/68/687187c7e26cb24ccbd88e5069f5ef00eba804d36dde11d99aad0838ab45/charset_normalizer-3.4.6-py3-none-any.whl", hash = "sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69", size = 61455, upload-time = "2026-03-15T18:53:23.833Z" },
 ]
 
 [[package]]
-name = "inflect"
-version = "7.5.0"
+name = "click"
+version = "8.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "more-itertools" },
-    { name = "typeguard" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/78/c6/943357d44a21fd995723d07ccaddd78023eace03c1846049a2645d4324a3/inflect-7.5.0.tar.gz", hash = "sha256:faf19801c3742ed5a05a8ce388e0d8fe1a07f8d095c82201eb904f5d27ad571f", size = 73751 }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/eb/427ed2b20a38a4ee29f24dbe4ae2dafab198674fe9a85e3d6adf9e5f5f41/inflect-7.5.0-py3-none-any.whl", hash = "sha256:2aea70e5e70c35d8350b8097396ec155ffd68def678c7ff97f51aa69c1d92344", size = 35197 },
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
 [[package]]
-name = "iniconfig"
-version = "2.1.0"
+name = "colorama"
+version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 },
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
 [[package]]
-name = "isort"
-version = "6.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b8/21/1e2a441f74a653a144224d7d21afe8f4169e6c7c20bb13aec3a2dc3815e0/isort-6.0.1.tar.gz", hash = "sha256:1cb5df28dfbc742e490c5e41bad6da41b805b0a8be7bc93cd0fb2a8a890ac450", size = 821955 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/11/114d0a5f4dabbdcedc1125dee0888514c3c3b16d3e9facad87ed96fad97c/isort-6.0.1-py3-none-any.whl", hash = "sha256:2dc5d7f65c9678d94c88dfc29161a320eec67328bc97aad576874cb4be1e9615", size = 94186 },
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/33/e8c48488c29a73fd089f9d71f9653c1be7478f2ad6b5bc870db11a55d23d/coverage-7.13.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e0723d2c96324561b9aa76fb982406e11d93cdb388a7a7da2b16e04719cf7ca5", size = 219255, upload-time = "2026-03-17T10:29:51.081Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bd/b0ebe9f677d7f4b74a3e115eec7ddd4bcf892074963a00d91e8b164a6386/coverage-7.13.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52f444e86475992506b32d4e5ca55c24fc88d73bcbda0e9745095b28ef4dc0cf", size = 219772, upload-time = "2026-03-17T10:29:52.867Z" },
+    { url = "https://files.pythonhosted.org/packages/48/cc/5cb9502f4e01972f54eedd48218bb203fe81e294be606a2bc93970208013/coverage-7.13.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:704de6328e3d612a8f6c07000a878ff38181ec3263d5a11da1db294fa6a9bdf8", size = 246532, upload-time = "2026-03-17T10:29:54.688Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/d8/3217636d86c7e7b12e126e4f30ef1581047da73140614523af7495ed5f2d/coverage-7.13.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a1a6d79a14e1ec1832cabc833898636ad5f3754a678ef8bb4908515208bf84f4", size = 248333, upload-time = "2026-03-17T10:29:56.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/30/2002ac6729ba2d4357438e2ed3c447ad8562866c8c63fc16f6dfc33afe56/coverage-7.13.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79060214983769c7ba3f0cee10b54c97609dca4d478fa1aa32b914480fd5738d", size = 250211, upload-time = "2026-03-17T10:29:57.938Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/85/552496626d6b9359eb0e2f86f920037c9cbfba09b24d914c6e1528155f7d/coverage-7.13.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:356e76b46783a98c2a2fe81ec79df4883a1e62895ea952968fb253c114e7f930", size = 252125, upload-time = "2026-03-17T10:29:59.388Z" },
+    { url = "https://files.pythonhosted.org/packages/44/21/40256eabdcbccdb6acf6b381b3016a154399a75fe39d406f790ae84d1f3c/coverage-7.13.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0cef0cdec915d11254a7f549c1170afecce708d30610c6abdded1f74e581666d", size = 247219, upload-time = "2026-03-17T10:30:01.199Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e8/96e2a6c3f21a0ea77d7830b254a1542d0328acc8d7bdf6a284ba7e529f77/coverage-7.13.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dc022073d063b25a402454e5712ef9e007113e3a676b96c5f29b2bda29352f40", size = 248248, upload-time = "2026-03-17T10:30:03.317Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ba/8477f549e554827da390ec659f3c38e4b6d95470f4daafc2d8ff94eaa9c2/coverage-7.13.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9b74db26dfea4f4e50d48a4602207cd1e78be33182bc9cbf22da94f332f99878", size = 246254, upload-time = "2026-03-17T10:30:04.832Z" },
+    { url = "https://files.pythonhosted.org/packages/55/59/bc22aef0e6aa179d5b1b001e8b3654785e9adf27ef24c93dc4228ebd5d68/coverage-7.13.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ad146744ca4fd09b50c482650e3c1b1f4dfa1d4792e0a04a369c7f23336f0400", size = 250067, upload-time = "2026-03-17T10:30:06.535Z" },
+    { url = "https://files.pythonhosted.org/packages/de/1b/c6a023a160806a5137dca53468fd97530d6acad24a22003b1578a9c2e429/coverage-7.13.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:c555b48be1853fe3997c11c4bd521cdd9a9612352de01fa4508f16ec341e6fe0", size = 246521, upload-time = "2026-03-17T10:30:08.486Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/3f/3532c85a55aa2f899fa17c186f831cfa1aa434d88ff792a709636f64130e/coverage-7.13.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7034b5c56a58ae5e85f23949d52c14aca2cfc6848a31764995b7de88f13a1ea0", size = 247126, upload-time = "2026-03-17T10:30:09.966Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2e/b9d56af4a24ef45dfbcda88e06870cb7d57b2b0bfa3a888d79b4c8debd76/coverage-7.13.5-cp310-cp310-win32.whl", hash = "sha256:eb7fdf1ef130660e7415e0253a01a7d5a88c9c4d158bcf75cbbd922fd65a5b58", size = 221860, upload-time = "2026-03-17T10:30:11.393Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cc/d938417e7a4d7f0433ad4edee8bb2acdc60dc7ac5af19e2a07a048ecbee3/coverage-7.13.5-cp310-cp310-win_amd64.whl", hash = "sha256:3e1bb5f6c78feeb1be3475789b14a0f0a5b47d505bfc7267126ccbd50289999e", size = 222788, upload-time = "2026-03-17T10:30:12.886Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
 ]
 
 [[package]]
-name = "jinja2"
-version = "3.1.6"
+name = "cryptography"
+version = "48.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markupsafe" },
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/bc/ee4137cbbe105652c0ee4252792b78fc8e7afa4b8e61d9d5dc05a7f45731/cryptography-48.0.1-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3e4a1a3232eef2e6c732827d5722db29a0cc8b27af2a4d865b094cf954be9ca1", size = 8008324, upload-time = "2026-06-09T22:31:00.702Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/85/6379d42181bfc713094f081360fc5784d6c816b599d45e7f082502d173ce/cryptography-48.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32143b24adb918f078134e1e230f1eb8cc04886b92c28b5f0041aaf3e5699225", size = 4696243, upload-time = "2026-06-09T22:32:33.446Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/87/c85d147b53323c7eb4d850920c8901377323c2a0ff8d79c262d4fee89aa2/cryptography-48.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0d27a5696721ef7a672b8c810f6aded391058e0b9486e63e6d93baf765da691", size = 4713235, upload-time = "2026-06-09T22:31:40.141Z" },
+    { url = "https://files.pythonhosted.org/packages/79/58/67cbf8cf1ee7c54b439ca07bbecf8362c07afc11a3724fea70f745784add/cryptography-48.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb86ce1af36fe65041b6db9a8bb064ee621a7e5fded0f80d475ec243477cd242", size = 4702323, upload-time = "2026-06-09T22:31:42.191Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c6/24266ac10c47f6cd2a865f4446062b466da1d1f10b27189eac00e61bf0c9/cryptography-48.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b024e784ad6c077ee0147b35ea9cbfc1e34e1fd4c1dcca214c2794d73a12df08", size = 5300085, upload-time = "2026-06-09T22:31:58.703Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bb/cc4b78784f97efc8c5874c2a9743708d172be6663024b34a0467885ae0c8/cryptography-48.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3752f2dbc8f07a30aad2932c986cea495b03bb554887828225da104f732852b6", size = 4746137, upload-time = "2026-06-09T22:31:31.01Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/52/0c44de3f5267f8fbe8e835138017522a333436166e406f0db9b9e6e3033f/cryptography-48.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:bd81490cd5801d755cf97bb68ac191f14b708470b1c7cf4580f669b9c9264cd8", size = 4333867, upload-time = "2026-06-09T22:32:28.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/2e/772d7adbfa931537bc401640b7cac9976bff689bda187833e5d63b428e49/cryptography-48.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:66fd0771e7b9c6dcd44cf1120690d2338d16d72795cf40cae2786a39eba65429", size = 4701805, upload-time = "2026-06-09T22:31:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/a3/b06844f303873493c963caf581c04df31c7035e0c1b0f02c4814d319ec80/cryptography-48.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:3fd2ca57062b241c856670b073487d2e86c4637937ca5601e48f97bf8e11fc8f", size = 5258461, upload-time = "2026-06-09T22:31:04.187Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/13/8b765e2e12b07c74941caadb9d1c8fdc006c4dfbf2b8f2d610519758954d/cryptography-48.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:0ee6ea481db1ab889cba043ec1eda17bb9c1ea79db6722f779c3667f9f70322f", size = 4745488, upload-time = "2026-06-09T22:32:30.07Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/aa/48972bce55049b32a94f4907eda4d75fa385aad8a39506cc2fc72196ecf0/cryptography-48.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2ceef93cb096aa3c4cc4b5c94ca6131f9196d28c64d6111533402a9b2054d41", size = 4830256, upload-time = "2026-06-09T22:31:43.868Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a2/e5079a032fb85cf6005046ca92bbd78b0c82dad2b5751ab8c311659da06f/cryptography-48.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9bd3f92d76217892b15df84ca256c2c113d386fdda7a7d8691aeeced976507c6", size = 4979117, upload-time = "2026-06-09T22:31:05.845Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/a0/8f50cae9c74e718ed769d63ed5c74bd0ea830c9550a74629cebd1b9c7bc7/cryptography-48.0.1-cp311-abi3-win32.whl", hash = "sha256:b9a32b876490d66c8bcc9963ef220199569748434ab01a9d6aaeabf88e7f5158", size = 3304154, upload-time = "2026-06-09T22:32:16.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/69/0572c77dbace6fef72f33755bd52ea399c71367250d366237f8691826b9e/cryptography-48.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:39489bfca54c7a1f6b297efcd8bc608ab92d16c4ca631b0cad4da46724588b24", size = 3817138, upload-time = "2026-06-09T22:32:00.388Z" },
+    { url = "https://files.pythonhosted.org/packages/42/06/3e768b4c3bc78201583fa35a0e18f640dd782ff41afba88f8545481a8874/cryptography-48.0.1-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:f817adc181390bd54f2f700107a7419040fb7c1bdf2fc26f36551a06a68c3345", size = 7989830, upload-time = "2026-06-09T22:31:07.8Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/13/6476736484b94041110c8340a3eb63962fea4975baea8cb4a512adb44d4d/cryptography-48.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d5d30989c6917b478b5817902e85fddaea2261efa8648383d965381ccb9e1ac4", size = 4689201, upload-time = "2026-06-09T22:31:09.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/62/65a87f34d2a431546e2509b85d55e8c90df86d668f6731da64d538512ac2/cryptography-48.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:df637c05205ea7c1d7fbcbe54bbfea648a52951155f997af13d895d0ecc96991", size = 4702822, upload-time = "2026-06-09T22:32:24.409Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/59/810b5204b0a9b10f4b6bc06bd551a8b609803cd931806bc3b71884b225e5/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:869c3b8a53bfe27147832df48b32adadf558249d50e76cb3769d40e986b13265", size = 4694875, upload-time = "2026-06-09T22:32:08.737Z" },
+    { url = "https://files.pythonhosted.org/packages/24/dc/d8ca05ffea724eec6d232ea6f18e74c269eb6bdfdcc9bfba689790d1325f/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:e361afba8918070d376df76f408a4f67fec0ee9cff81a99e48fe9a233ef59e17", size = 5290385, upload-time = "2026-06-09T22:31:15.212Z" },
+    { url = "https://files.pythonhosted.org/packages/03/8c/3be6cb4da181f5bb6c19cf560c2359d60644a6b5fc5b57854e528f47b296/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:d069066deead00ac7f090be101be875a06855908f7ec004c27b8fefb4acfb411", size = 4737082, upload-time = "2026-06-09T22:32:22.66Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/f6/d5f60a5a1434dbfd949e227fd0065d194c7e6b6ac526b17f5c06152b8231/cryptography-48.0.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:09f73a725d582cef64b91281a322cd798d14a33b2b6f2b7ad9531dc336d84c02", size = 4325328, upload-time = "2026-06-09T22:32:10.777Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b7/ba75dd947a14b6ad907b01ae8f6b5b348cdd1b48142f0063dee9e20c1d9d/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:15254441469dd6bf027039453288e2072124f8b6603563f5d759e1c9b69273fa", size = 4694530, upload-time = "2026-06-09T22:31:53.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/50d6b9e8aff12d8b67afaeb3569335e32dc83a5723e3bbded24fdac9f809/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:8ace4507d1e6533c125f4fac754f8bb8b6a74c08e92179dabd7e16571a3efbf3", size = 5245046, upload-time = "2026-06-09T22:31:25.774Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/04/618f4115cfc0add0838c82507aa18a346089428da8653ad38b3ff36f5cb3/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:b4e391975f038e66432328639620a4aff2d307513b004f1ca06d6225bced815c", size = 4736660, upload-time = "2026-06-09T22:32:12.676Z" },
+    { url = "https://files.pythonhosted.org/packages/24/9c/06e062462a0de28a3b3911322eded4c16deb9f441b1b7575d3dc59488ab5/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42fcd8e26fe555d9b3577a135f5091fefa0aa4e99129c23fb56787a1bd4ada72", size = 4822229, upload-time = "2026-06-09T22:31:17.062Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/be/0561971eaaee4b8a0e7d5113c536921063ab91aaf23278ac374eaf881e11/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1400da5e32a43253392277eac7490a60e497d810a63dd5608d71bbd7af507c9", size = 4966364, upload-time = "2026-06-09T22:31:32.842Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/27/728c77876f12b000820b69ae490f3c4083775e79e07827e9e60be07ad209/cryptography-48.0.1-cp314-cp314t-win32.whl", hash = "sha256:0df56b056bc17c1b7d6821dfa65216e62bd232d8ab05eb3db44e71d235651471", size = 3278498, upload-time = "2026-06-09T22:31:29.154Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/79a612c6d7b1e6ee0edd43633d53035bec2cfb78c82b76f7864f39e36f34/cryptography-48.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:9de21387aa95e2a895823d0745b430bed4f33503ba9ab5e0b5311f33e37d66d2", size = 3798790, upload-time = "2026-06-09T22:31:56.697Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/6c/00fa2a95997164c8b2072ce327c23d4ab20809ccc323ea5fab91e53a4bba/cryptography-48.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:4fdc69f8e4316bcf0c8c8ec1f26f285d12e8142d88d96c876a59a03be3f6ae67", size = 7987408, upload-time = "2026-06-09T22:32:20.777Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/d9/45f309a7e4e5f3f8f121d6d3be9e94024a7726ec598d6e08ae04edb2f04d/cryptography-48.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48fe40804d4caa2288f24e70ca8c64c42dd826da0ad7e4f1b41b2128d679e6c8", size = 4690196, upload-time = "2026-06-09T22:31:54.74Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9f/a1bc8bcc798811b8527eb374bbccf30a3f3e806829d967118222bf1125eb/cryptography-48.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:86be3b1b0b6bf09482fb50a979c508d2950ed95f5621ec77f4e385962006b83a", size = 4696782, upload-time = "2026-06-09T22:31:45.615Z" },
+    { url = "https://files.pythonhosted.org/packages/66/c2/81a4fb4e4373c500bb526bc337ac5719dd31dd15b970b84a238168c6aa08/cryptography-48.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4ab0a343c807bbcd90c971cd1ecf072937cd01847a9e002bef88fb47ac6be577", size = 4696618, upload-time = "2026-06-09T22:31:11.564Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/0b/aa68b221dde92d09cb29a024ede17550ee21e77a404e59fc093c82bb51e1/cryptography-48.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9621de99d2da096006b629979efd8ae7eb2d8b822488d0c89ee4000c306c59b1", size = 5289970, upload-time = "2026-06-09T22:31:20.368Z" },
+    { url = "https://files.pythonhosted.org/packages/78/13/fba657f958d2af66ea959a4ba01212632089249d34af1ae48054136344d7/cryptography-48.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:88c852a0ae366e262e5a1744b685e6a433dc8788dd2a277e418bf4904203609d", size = 4731873, upload-time = "2026-06-09T22:31:22.253Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/4c/9a964756d24a26b3e34dfcb16f961b89838786e6700b635b0d1e3adff4b6/cryptography-48.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:43c5835e2cb98c8733d86f57d6fc879b613f5c3478607281c3e36daffc6dd8a6", size = 4330804, upload-time = "2026-06-09T22:31:36.56Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/0f/a10f3a6eb12950a10e3a874070283aa2dd5875b2bfd15fad8a3e17b3f13e/cryptography-48.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:fe0180af5bf9236518a087e35bf2d9a347d5f5f51e63c579d683ddff424e3d46", size = 4696217, upload-time = "2026-06-09T22:31:13.351Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6f/5cd12f951165ea73ef85266775d97e4c763b2474ccfd816dd69d3a18d6f8/cryptography-48.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:b7a2d1a937a738a881737cec135a38bb61470589b17515b9f73f571d0ae10401", size = 5245252, upload-time = "2026-06-09T22:32:02.193Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/8aaa12e4516ec4464033ab79b6f3b592bd5a92102467c4ace8a0d970203f/cryptography-48.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b74ca3b8e5ecdd833bf6a002ca41b4793bb27fb8f1c06ffaf2643c9e9140e31b", size = 4731388, upload-time = "2026-06-09T22:32:04.019Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/24/50027ea4dca85ec1f40688f3c24fb32ccacd520583c9592c3cc95628e6fb/cryptography-48.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2c37f2461406063b417837f5f3daab668652acd82423efcd7f0a9f04be972de1", size = 4824186, upload-time = "2026-06-09T22:32:18.707Z" },
+    { url = "https://files.pythonhosted.org/packages/52/41/04cb5eb17085ade6f50cc611fb657df6a0f5885350de8764ece89c050197/cryptography-48.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:86fe77abb1bd87afb251d4d02ada7ecf53a32cee9b67d976abb2e45a13297475", size = 4964539, upload-time = "2026-06-09T22:31:18.793Z" },
+    { url = "https://files.pythonhosted.org/packages/36/bf/ed70785c496e89d7e73b7cda2d21f2447fd6d4e821714b8d04ff217fed92/cryptography-48.0.1-cp39-abi3-win32.whl", hash = "sha256:6b2c0c3e6ccf3ade7750f836ef3ee36eea250cc467d45c256895573ac08cc6f1", size = 3282307, upload-time = "2026-06-09T22:30:53.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ff/371ea7d252656ee1eb6d83eeeef3d1d0c6baf1d6497687d081ea03814670/cryptography-48.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:9a49ca6c81417f6a5edb50375a60cccdd70fa0a91a5211829dbea74eba94d2ac", size = 3793408, upload-time = "2026-06-09T22:32:15.191Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d3/eb4e394e587341fdad09a09101fa76478ead3a78b0ad63e55c22f0d75c02/cryptography-48.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:08a597acce1ff37f347400087776599e2348a3a8bc53b44120e463cd274efe4a", size = 3951747, upload-time = "2026-06-09T22:31:23.871Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/3f43451b4f858bfceaaaffc649e6e787e8d4fb332a1d443af39ab02cc8f1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:735824ec41b7f74a7c45fb1591349333e4c696cb6c044e5f46356e560143e4cd", size = 4641226, upload-time = "2026-06-09T22:31:02.532Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4e/855584c2c23b09e4ce2d3b9c30e983e679cd60b068c513c6bbdb91e11782/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:92a46e1d638daa264ba2971c0b0489c9409787943efae4d60ffda3d091ef832c", size = 4668958, upload-time = "2026-06-09T22:32:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/42/3b/d35750e41d803d1e516fd6d6011f065424924da7af1748cef4cc9cb3ede1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7e234ac052af99f2700826a5c29ea99d9c1b1f80341cde62d11c8154dc8e0bd9", size = 4640793, upload-time = "2026-06-09T22:32:26.331Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/aa/cdb7181fe865285e87e96825aaab239400f1de0c3bfba9bd9769b79f1a92/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:33842cf0888951cef5bc7ac724ab844a42044c1727b967b7f8997289a0464f92", size = 4668505, upload-time = "2026-06-09T22:31:27.534Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8c/ce3823c06c2804f194f9e64f0d67fa3f4094a39f2bb1a990cd03603af8fc/cryptography-48.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6184ca7b174f28d7c703f1290d4b297217c45355f77a98f67e9b7f14549ac54a", size = 3742204, upload-time = "2026-06-09T22:31:34.773Z" },
+]
+
+[[package]]
+name = "culsans"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiologic" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or python_full_version >= '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/e3/49afa1bc180e0d28008ec6bcdf82a4072d1c7a41032b5b759b60814ca4b0/culsans-0.11.0.tar.gz", hash = "sha256:0b43d0d05dce6106293d114c86e3fb4bfc63088cfe8ff08ed3fe36891447fe33", size = 107546, upload-time = "2025-12-31T23:15:38.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/5d/9fb19fb38f6d6120422064279ea5532e22b84aa2be8831d49607194feda3/culsans-0.11.0-py3-none-any.whl", hash = "sha256:278d118f63fc75b9db11b664b436a1b83cc30d9577127848ba41420e66eb5a47", size = 21811, upload-time = "2025-12-31T23:15:37.189Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" },
+]
+
+[[package]]
+name = "dunamai"
+version = "1.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/c4/346cef905782df6152f29f02d9c8ed4acf7ae66b0e66210b7156c5575ccb/dunamai-1.26.0.tar.gz", hash = "sha256:5396ac43aa20ed059040034e9f9798c7464cf4334c6fc3da3732e29273a2f97d", size = 45500, upload-time = "2026-02-15T02:58:55.534Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 },
+    { url = "https://files.pythonhosted.org/packages/87/10/2c7edbf230e5c507d38367af498fa94258ed97205d9b4b6f63a921fe9c49/dunamai-1.26.0-py3-none-any.whl", hash = "sha256:f584edf0fda0d308cce0961f807bc90a8fe3d9ff4d62f94e72eca7b43f0ed5f6", size = 27322, upload-time = "2026-02-15T02:58:54.143Z" },
 ]
 
 [[package]]
-name = "jsonpatch"
-version = "1.33"
+name = "exceptiongroup"
+version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jsonpointer" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" } },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699 }
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898 },
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
 ]
 
 [[package]]
-name = "jsonpointer"
-version = "3.0.0"
+name = "execnet"
+version = "2.1.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114 }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 },
+    { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },
 ]
 
 [[package]]
-name = "langchain-core"
-version = "0.3.59"
+name = "fastapi"
+version = "0.136.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jsonpatch" },
-    { name = "langsmith" },
-    { name = "packaging" },
+    { name = "annotated-doc" },
     { name = "pydantic" },
-    { name = "pyyaml" },
-    { name = "tenacity" },
-    { name = "typing-extensions" },
+    { name = "starlette" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/78/d17dae349301712e5b1bb4c0c98ecf84c566a71666fbcb1d4006c67b043a/langchain_core-0.3.59.tar.gz", hash = "sha256:052a37cf298c505144f007e5aeede6ecff2dc92c827525d1ef59101eb3a4551c", size = 557225 }
+sdist = { url = "https://files.pythonhosted.org/packages/81/2d/ff8d91d7b564d464629a0fd50a4489c97fcb836ac230bf3a7269232a9b1f/fastapi-0.136.3.tar.gz", hash = "sha256:e487fae93ad408e6f47641ee4dfe389864fd7bec92e547ea8498fc13f43e83ab", size = 396410, upload-time = "2026-05-23T18:53:15.192Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/40/aa440a7cd05f1dab5d7c91a1284eb776c3cf3eb59fa18ed39927650cfa38/langchain_core-0.3.59-py3-none-any.whl", hash = "sha256:9686baaff43f2c8175535da13faf40e6866769015e93130c3c1e4243e7244d70", size = 437656 },
+    { url = "https://files.pythonhosted.org/packages/e0/82/45359b62a067409bd929ae8a56b8ed13e5a8c8a61194b3c236920999ab83/fastapi-0.136.3-py3-none-any.whl", hash = "sha256:3d2a69bdf04b7e9f3afa292c3bc7a98816bbfafa10bc9b45f3f3700d2f761620", size = 117481, upload-time = "2026-05-23T18:53:16.924Z" },
 ]
 
 [[package]]
-name = "langchain-google-genai"
-version = "2.1.4"
+name = "filelock"
+version = "3.25.2"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "filetype" },
-    { name = "google-ai-generativelanguage" },
-    { name = "langchain-core" },
-    { name = "pydantic" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/81/48/73cb0a186f028a3597a825c930957a032895960381af505fa93805fe1736/langchain_google_genai-2.1.4.tar.gz", hash = "sha256:b52e10ea3daf1a65f70b73c78b78235466593de2aa9f4119fa887b804605efb7", size = 40368 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/12/2be71bebbc23e4a499c50df567017110e4d382a045422647c8e6b1040541/langchain_google_genai-2.1.4-py3-none-any.whl", hash = "sha256:a3fa3cf7fe9c1de77280f42fbdd22cfcc5fbeb0d60cd5be7a0e6c50a74f5ce73", size = 44313 },
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
 ]
 
 [[package]]
-name = "langgraph"
-version = "0.4.3"
+name = "google-api-core"
+version = "2.31.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "langchain-core", marker = "python_full_version < '4.0'" },
-    { name = "langgraph-checkpoint" },
-    { name = "langgraph-prebuilt", marker = "python_full_version < '4.0'" },
-    { name = "langgraph-sdk", marker = "python_full_version < '4.0'" },
-    { name = "pydantic" },
-    { name = "xxhash" },
+    { name = "google-auth" },
+    { name = "googleapis-common-protos" },
+    { name = "proto-plus" },
+    { name = "protobuf" },
+    { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/60/9e/5a64602eff18a99d0216a80eff823051ffbdb7c11b5a16171cee8b1ccce5/langgraph-0.4.3.tar.gz", hash = "sha256:272d5d5903f2c2882dbeeba849846a0f2500bd83fb3734a3801ebe64c1a60bdd", size = 125407 }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/22/155cadf1d49272a9cf48f3168c0f3874fa13397297e611a5ea00cd093880/google_api_core-2.31.0.tar.gz", hash = "sha256:2be84ee0f584c48e6bde1b36766e23348b361fb7e55e56135fc76ce1c397f9c2", size = 176492, upload-time = "2026-06-03T14:52:17.257Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/53/0a20edd9f41eb3707722444ec1b43752b792bbe904d1c8cc3ba27f8eb2c8/langgraph-0.4.3-py3-none-any.whl", hash = "sha256:dec926e034f4d440b92a3c52139cb6e9763bc1791e79a6ea53a233309cec864f", size = 151191 },
+    { url = "https://files.pythonhosted.org/packages/86/40/9bdbb60b03a332bd45acb8703da08bbc27d991d35286b62e42acc86d243a/google_api_core-2.31.0-py3-none-any.whl", hash = "sha256:ef79fb3784c71cbac89cbd03301ba0c8fb8ad2aa95d7f9204dd9628f7adf59ab", size = 173102, upload-time = "2026-06-03T14:51:26.729Z" },
 ]
 
 [[package]]
-name = "langgraph-checkpoint"
-version = "2.0.25"
+name = "google-auth"
+version = "2.49.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "langchain-core" },
-    { name = "ormsgpack" },
+    { name = "cryptography" },
+    { name = "pyasn1-modules" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c5/72/d49828e6929cb3ded1472aa3e5e4a369d292c4f21021ac683d28fbc8f4f8/langgraph_checkpoint-2.0.25.tar.gz", hash = "sha256:77a63cab7b5f84dec1d49db561326ec28bdd48bcefb7fe4ac372069d2609287b", size = 36952 }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/80/6a696a07d3d3b0a92488933532f03dbefa4a24ab80fb231395b9a2a1be77/google_auth-2.49.1.tar.gz", hash = "sha256:16d40da1c3c5a0533f57d268fe72e0ebb0ae1cc3b567024122651c045d879b64", size = 333825, upload-time = "2026-03-12T19:30:58.135Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/52/bceb5b5348c7a60ef0625ab0a0a0a9ff5d78f0e12aed8cc55c49d5e8a8c9/langgraph_checkpoint-2.0.25-py3-none-any.whl", hash = "sha256:23416a0f5bc9dd712ac10918fc13e8c9c4530c419d2985a441df71a38fc81602", size = 42312 },
+    { url = "https://files.pythonhosted.org/packages/e9/eb/c6c2478d8a8d633460be40e2a8a6f8f429171997a35a96f81d3b680dec83/google_auth-2.49.1-py3-none-any.whl", hash = "sha256:195ebe3dca18eddd1b3db5edc5189b76c13e96f29e73043b923ebcf3f1a860f7", size = 240737, upload-time = "2026-03-12T19:30:53.159Z" },
 ]
 
 [[package]]
-name = "langgraph-example"
-version = "0.1.0"
-source = { editable = "examples/langgraph" }
+name = "googleapis-common-protos"
+version = "1.75.0"
+source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "a2a-sdk" },
-    { name = "click" },
-    { name = "dotenv" },
-    { name = "httpx" },
-    { name = "langchain-google-genai" },
-    { name = "langgraph" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "uvicorn" },
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/c8/f439cffde755cffa462bfbb156278fa6f9d09119719af9814b858fd4f81f/googleapis_common_protos-1.75.0.tar.gz", hash = "sha256:53a062ff3c32552fbd62c11fe23768b78e4ddf0494d5e5fd97d3f4689c75fbbd", size = 151035, upload-time = "2026-05-07T08:04:49.423Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/c8/e2645aa8ed02fd4c7a2f59d68783b65b1f3cbdfe39a6308e156509d1fee8/googleapis_common_protos-1.75.0-py3-none-any.whl", hash = "sha256:961ed60399c457ceb0ee8f285a84c870aabc9c6a832b9d37bb281b5bebde43ed", size = 300631, upload-time = "2026-05-07T08:03:30.345Z" },
 ]
 
-[package.metadata]
-requires-dist = [
-    { name = "a2a-sdk", editable = "." },
-    { name = "click", specifier = ">=8.1.8" },
-    { name = "dotenv", specifier = ">=0.9.9" },
-    { name = "httpx", specifier = ">=0.28.1" },
-    { name = "langchain-google-genai", specifier = ">=2.1.4" },
-    { name = "langgraph", specifier = ">=0.4.1" },
-    { name = "pydantic", specifier = ">=2.11.4" },
-    { name = "python-dotenv", specifier = ">=1.1.0" },
-    { name = "uvicorn", specifier = ">=0.34.2" },
+[[package]]
+name = "greenlet"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/51/1664f6b78fc6ebbd98019a1fd730e83fa78f2db7058f72b1463d3612b8db/greenlet-3.3.2.tar.gz", hash = "sha256:2eaf067fc6d886931c7962e8c6bede15d2f01965560f3359b27c80bde2d151f2", size = 188267, upload-time = "2026-02-20T20:54:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/3f/9859f655d11901e7b2996c6e3d33e0caa9a1d4572c3bc61ed0faa64b2f4c/greenlet-3.3.2-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9bc885b89709d901859cf95179ec9f6bb67a3d2bb1f0e88456461bd4b7f8fd0d", size = 277747, upload-time = "2026-02-20T20:16:21.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/07/cb284a8b5c6498dbd7cba35d31380bb123d7dceaa7907f606c8ff5993cbf/greenlet-3.3.2-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b568183cf65b94919be4438dc28416b234b678c608cafac8874dfeeb2a9bbe13", size = 579202, upload-time = "2026-02-20T20:47:28.955Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/45/67922992b3a152f726163b19f890a85129a992f39607a2a53155de3448b8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:527fec58dc9f90efd594b9b700662ed3fb2493c2122067ac9c740d98080a620e", size = 590620, upload-time = "2026-02-20T20:55:55.581Z" },
+    { url = "https://files.pythonhosted.org/packages/03/5f/6e2a7d80c353587751ef3d44bb947f0565ec008a2e0927821c007e96d3a7/greenlet-3.3.2-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508c7f01f1791fbc8e011bd508f6794cb95397fdb198a46cb6635eb5b78d85a7", size = 602132, upload-time = "2026-02-20T21:02:43.261Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/55/9f1ebb5a825215fadcc0f7d5073f6e79e3007e3282b14b22d6aba7ca6cb8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad0c8917dd42a819fe77e6bdfcb84e3379c0de956469301d9fd36427a1ca501f", size = 591729, upload-time = "2026-02-20T20:20:58.395Z" },
+    { url = "https://files.pythonhosted.org/packages/24/b4/21f5455773d37f94b866eb3cf5caed88d6cea6dd2c6e1f9c34f463cba3ec/greenlet-3.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:97245cc10e5515dbc8c3104b2928f7f02b6813002770cfaffaf9a6e0fc2b94ef", size = 1551946, upload-time = "2026-02-20T20:49:31.102Z" },
+    { url = "https://files.pythonhosted.org/packages/00/68/91f061a926abead128fe1a87f0b453ccf07368666bd59ffa46016627a930/greenlet-3.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8c1fdd7d1b309ff0da81d60a9688a8bd044ac4e18b250320a96fc68d31c209ca", size = 1618494, upload-time = "2026-02-20T20:21:06.541Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/78/f93e840cbaef8becaf6adafbaf1319682a6c2d8c1c20224267a5c6c8c891/greenlet-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:5d0e35379f93a6d0222de929a25ab47b5eb35b5ef4721c2b9cbcc4036129ff1f", size = 230092, upload-time = "2026-02-20T20:17:09.379Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/47/16400cb42d18d7a6bb46f0626852c1718612e35dcb0dffa16bbaffdf5dd2/greenlet-3.3.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:c56692189a7d1c7606cb794be0a8381470d95c57ce5be03fb3d0ef57c7853b86", size = 278890, upload-time = "2026-02-20T20:19:39.263Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/90/42762b77a5b6aa96cd8c0e80612663d39211e8ae8a6cd47c7f1249a66262/greenlet-3.3.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ebd458fa8285960f382841da585e02201b53a5ec2bac6b156fc623b5ce4499f", size = 581120, upload-time = "2026-02-20T20:47:30.161Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/6f/f3d64f4fa0a9c7b5c5b3c810ff1df614540d5aa7d519261b53fba55d4df9/greenlet-3.3.2-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a443358b33c4ec7b05b79a7c8b466f5d275025e750298be7340f8fc63dff2a55", size = 594363, upload-time = "2026-02-20T20:55:56.965Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/8b/1430a04657735a3f23116c2e0d5eb10220928846e4537a938a41b350bed6/greenlet-3.3.2-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4375a58e49522698d3e70cc0b801c19433021b5c37686f7ce9c65b0d5c8677d2", size = 605046, upload-time = "2026-02-20T21:02:45.234Z" },
+    { url = "https://files.pythonhosted.org/packages/72/83/3e06a52aca8128bdd4dcd67e932b809e76a96ab8c232a8b025b2850264c5/greenlet-3.3.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e2cd90d413acbf5e77ae41e5d3c9b3ac1d011a756d7284d7f3f2b806bbd6358", size = 594156, upload-time = "2026-02-20T20:20:59.955Z" },
+    { url = "https://files.pythonhosted.org/packages/70/79/0de5e62b873e08fe3cef7dbe84e5c4bc0e8ed0c7ff131bccb8405cd107c8/greenlet-3.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:442b6057453c8cb29b4fb36a2ac689382fc71112273726e2423f7f17dc73bf99", size = 1554649, upload-time = "2026-02-20T20:49:32.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/00/32d30dee8389dc36d42170a9c66217757289e2afb0de59a3565260f38373/greenlet-3.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45abe8eb6339518180d5a7fa47fa01945414d7cca5ecb745346fc6a87d2750be", size = 1619472, upload-time = "2026-02-20T20:21:07.966Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/3a/efb2cf697fbccdf75b24e2c18025e7dfa54c4f31fab75c51d0fe79942cef/greenlet-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e692b2dae4cc7077cbb11b47d258533b48c8fde69a33d0d8a82e2fe8d8531d5", size = 230389, upload-time = "2026-02-20T20:17:18.772Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/a1/65bbc059a43a7e2143ec4fc1f9e3f673e04f9c7b371a494a101422ac4fd5/greenlet-3.3.2-cp311-cp311-win_arm64.whl", hash = "sha256:02b0a8682aecd4d3c6c18edf52bc8e51eacdd75c8eac52a790a210b06aa295fd", size = 229645, upload-time = "2026-02-20T20:18:18.695Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd", size = 280358, upload-time = "2026-02-20T20:17:43.971Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/23/0eae412a4ade4e6623ff7626e38998cb9b11e9ff1ebacaa021e4e108ec15/greenlet-3.3.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ceec72030dae6ac0c8ed7591b96b70410a8be370b6a477b1dbc072856ad02bd", size = 601217, upload-time = "2026-02-20T20:47:31.462Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/16/5b1678a9c07098ecb9ab2dd159fafaf12e963293e61ee8d10ecb55273e5e/greenlet-3.3.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2a5be83a45ce6188c045bcc44b0ee037d6a518978de9a5d97438548b953a1ac", size = 611792, upload-time = "2026-02-20T20:55:58.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/c5/cc09412a29e43406eba18d61c70baa936e299bc27e074e2be3806ed29098/greenlet-3.3.2-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ae9e21c84035c490506c17002f5c8ab25f980205c3e61ddb3a2a2a2e6c411fcb", size = 626250, upload-time = "2026-02-20T21:02:46.596Z" },
+    { url = "https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070", size = 613875, upload-time = "2026-02-20T20:21:01.102Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/dd/845f249c3fcd69e32df80cdab059b4be8b766ef5830a3d0aa9d6cad55beb/greenlet-3.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4c956a19350e2c37f2c48b336a3afb4bff120b36076d9d7fb68cb44e05d95b79", size = 1571467, upload-time = "2026-02-20T20:49:33.495Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/50/2649fe21fcc2b56659a452868e695634722a6655ba245d9f77f5656010bf/greenlet-3.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c6f8ba97d17a1e7d664151284cb3315fc5f8353e75221ed4324f84eb162b395", size = 1640001, upload-time = "2026-02-20T20:21:09.154Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/cc802e067d02af8b60b6771cea7d57e21ef5e6659912814babb42b864713/greenlet-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:34308836d8370bddadb41f5a7ce96879b72e2fdfb4e87729330c6ab52376409f", size = 231081, upload-time = "2026-02-20T20:17:28.121Z" },
+    { url = "https://files.pythonhosted.org/packages/58/2e/fe7f36ff1982d6b10a60d5e0740c759259a7d6d2e1dc41da6d96de32fff6/greenlet-3.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:d3a62fa76a32b462a97198e4c9e99afb9ab375115e74e9a83ce180e7a496f643", size = 230331, upload-time = "2026-02-20T20:17:23.34Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/48/f8b875fa7dea7dd9b33245e37f065af59df6a25af2f9561efa8d822fde51/greenlet-3.3.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:aa6ac98bdfd716a749b84d4034486863fd81c3abde9aa3cf8eff9127981a4ae4", size = 279120, upload-time = "2026-02-20T20:19:01.9Z" },
+    { url = "https://files.pythonhosted.org/packages/49/8d/9771d03e7a8b1ee456511961e1b97a6d77ae1dea4a34a5b98eee706689d3/greenlet-3.3.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab0c7e7901a00bc0a7284907273dc165b32e0d109a6713babd04471327ff7986", size = 603238, upload-time = "2026-02-20T20:47:32.873Z" },
+    { url = "https://files.pythonhosted.org/packages/59/0e/4223c2bbb63cd5c97f28ffb2a8aee71bdfb30b323c35d409450f51b91e3e/greenlet-3.3.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d248d8c23c67d2291ffd47af766e2a3aa9fa1c6703155c099feb11f526c63a92", size = 614219, upload-time = "2026-02-20T20:55:59.817Z" },
+    { url = "https://files.pythonhosted.org/packages/94/2b/4d012a69759ac9d77210b8bfb128bc621125f5b20fc398bce3940d036b1c/greenlet-3.3.2-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccd21bb86944ca9be6d967cf7691e658e43417782bce90b5d2faeda0ff78a7dd", size = 628268, upload-time = "2026-02-20T21:02:48.024Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/34/259b28ea7a2a0c904b11cd36c79b8cef8019b26ee5dbe24e73b469dea347/greenlet-3.3.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6997d360a4e6a4e936c0f9625b1c20416b8a0ea18a8e19cabbefc712e7397ab", size = 616774, upload-time = "2026-02-20T20:21:02.454Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/03/996c2d1689d486a6e199cb0f1cf9e4aa940c500e01bdf201299d7d61fa69/greenlet-3.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64970c33a50551c7c50491671265d8954046cb6e8e2999aacdd60e439b70418a", size = 1571277, upload-time = "2026-02-20T20:49:34.795Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/c4/2570fc07f34a39f2caf0bf9f24b0a1a0a47bc2e8e465b2c2424821389dfc/greenlet-3.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a9172f5bf6bd88e6ba5a84e0a68afeac9dc7b6b412b245dd64f52d83c81e55b", size = 1640455, upload-time = "2026-02-20T20:21:10.261Z" },
+    { url = "https://files.pythonhosted.org/packages/91/39/5ef5aa23bc545aa0d31e1b9b55822b32c8da93ba657295840b6b34124009/greenlet-3.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:a7945dd0eab63ded0a48e4dcade82939783c172290a7903ebde9e184333ca124", size = 230961, upload-time = "2026-02-20T20:16:58.461Z" },
+    { url = "https://files.pythonhosted.org/packages/62/6b/a89f8456dcb06becff288f563618e9f20deed8dd29beea14f9a168aef64b/greenlet-3.3.2-cp313-cp313-win_arm64.whl", hash = "sha256:394ead29063ee3515b4e775216cb756b2e3b4a7e55ae8fd884f17fa579e6b327", size = 230221, upload-time = "2026-02-20T20:17:37.152Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/ac/85804f74f1ccea31ba518dcc8ee6f14c79f73fe36fa1beba38930806df09/greenlet-3.3.2-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e3cb43ce200f59483eb82949bf1835a99cf43d7571e900d7c8d5c62cdf25d2f9", size = 675371, upload-time = "2026-02-20T21:02:49.664Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" },
+    { url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ca/2101ca3d9223a1dc125140dbc063644dca76df6ff356531eb27bc267b446/greenlet-3.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:8c4dd0f3997cf2512f7601563cc90dfb8957c0cff1e3a1b23991d4ea1776c492", size = 232034, upload-time = "2026-02-20T20:20:08.186Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/4a/ecf894e962a59dea60f04877eea0fd5724618da89f1867b28ee8b91e811f/greenlet-3.3.2-cp314-cp314-win_arm64.whl", hash = "sha256:cd6f9e2bbd46321ba3bbb4c8a15794d32960e3b0ae2cc4d49a1a53d314805d71", size = 231437, upload-time = "2026-02-20T20:18:59.722Z" },
+    { url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/67/8197b7e7e602150938049d8e7f30de1660cfb87e4c8ee349b42b67bdb2e1/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:59b3e2c40f6706b05a9cd299c836c6aa2378cabe25d021acd80f13abf81181cf", size = 666581, upload-time = "2026-02-20T21:02:51.526Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4b/45d90626aef8e65336bed690106d1382f7a43665e2249017e9527df8823b/greenlet-3.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c04c5e06ec3e022cbfe2cd4a846e1d4e50087444f875ff6d2c2ad8445495cf1a", size = 237086, upload-time = "2026-02-20T20:20:45.786Z" },
 ]
 
 [[package]]
-name = "langgraph-prebuilt"
-version = "0.1.8"
+name = "grpcio"
+version = "1.84.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3f/4f/4435c0aae54657258d9cfcba78598f3d9e5fe4c82ff18d78558567b90faf/grpcio-1.84.0.tar.gz", hash = "sha256:19aaf172fc2edbefccce3f6e92c5150975dbe56c45744e9e87cf72ebdf85bfbe", size = 13493876, upload-time = "2026-09-14T06:59:33.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/4b/a0dc421d049b743093eae90caeb5dd92ced7226cd4919dc4de34c81455b6/grpcio-1.84.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:71fd60e6e426d293d0a2f685115ad0a0845117602cf13605a4be7524fb5f7bba", size = 6450049, upload-time = "2026-09-14T06:56:48.72Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/41/90292bf55af7aa09de0e3ec928d1b8c56d477f85244f7928d2231630b781/grpcio-1.84.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:8e1a45d174b6b8589f51dce1cea804aa6c1f72c9c80cba91ae2caabeb6d90540", size = 12344932, upload-time = "2026-09-14T06:56:51.685Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/68/b6c0248266a378b1bde08e4de7d69f3cc08ee6f5937a5dce7d3c3ba0fe1d/grpcio-1.84.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:efb29f8633bf6630dc89de4fe0353ac3d7e4b70ef7b6e29fb40f00e68c127fa5", size = 7030162, upload-time = "2026-09-14T06:56:54.412Z" },
+    { url = "https://files.pythonhosted.org/packages/70/2b/0a2a2cbcf48847f83eb51fb982116d0965f2fe068e73f28b2d17facf30a4/grpcio-1.84.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d0fdd25faece8a1f95e8a3a8006e29701b5cf8dadb4a8132e68f3134637004a5", size = 7781546, upload-time = "2026-09-14T06:56:56.571Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/7c/da97476f3c2e90e9f00bfb19def7cbb5f841b7661e3cd09c6a89beaa5b98/grpcio-1.84.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:393d8a78bff6731ecc5ad2151a821f8fbc1709b137ebb9c25a4ef399fbdcc914", size = 7186279, upload-time = "2026-09-14T06:56:58.817Z" },
+    { url = "https://files.pythonhosted.org/packages/14/16/27fa3aed1ee6fdcbb978a1bd4bce255dc0122b90179535177a96543d14fc/grpcio-1.84.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fc66cb50c93554b86db0b6625ab5c6e9051dbf8847c08d93c84918e02e413fb7", size = 7731191, upload-time = "2026-09-14T06:57:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/78/75644af37af85afb381376aef99cad92da8bc2d56ba3e5ae070a7cb59682/grpcio-1.84.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:455ed6083353b8e938f1d58c765eab2fbb165731e5b507be30fee344915a2a11", size = 8790443, upload-time = "2026-09-14T06:57:04.623Z" },
+    { url = "https://files.pythonhosted.org/packages/95/4d/ce57fa986e93c06ef867f64e1ebe419e924fdc2395115607f0725f4855e4/grpcio-1.84.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d6a82c4fc6c85f2fb7572c86bdb86f84c97b6580e5f6599f711800bac48a5d8", size = 8138068, upload-time = "2026-09-14T06:57:07.348Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/a6/22a73111c4f75da9450bf0481fac805396ec9bf6f949a90bb2969de07cf4/grpcio-1.84.0-cp310-cp310-win32.whl", hash = "sha256:8e3f508d0e9e6236ba2f08d56e33355e434e785e813149a1b8477d3edf69779d", size = 4496545, upload-time = "2026-09-14T06:57:09.236Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ff/dc048bc3d8ebd8d4b7f6f6803c76142a9a5ca1e1e9fa34e79597f0f9ed77/grpcio-1.84.0-cp310-cp310-win_amd64.whl", hash = "sha256:ed2c1493c44d0932f1e55fdb5d1ead658c68288ec5d51b8c4928422d98633ef9", size = 5258144, upload-time = "2026-09-14T06:57:11.403Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/b9/46146728b3f4a5c7e34c17d0ab724d58b5456b116e76dc77d3ef4e79b135/grpcio-1.84.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:4aaeceeb7fa7d824c322d1ec3208c8495c88478a927295553235435fc49043ad", size = 6454572, upload-time = "2026-09-14T06:57:14.651Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/5d668b4102637410d700153fd12d6a798e3ff8308bd9dcbaeae93f191060/grpcio-1.84.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:06619ba1515e5ee69fb2a514e95dd8be05ce74cb3928d5b34f87f87c86fe3c27", size = 12359529, upload-time = "2026-09-14T06:57:17.202Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2a/52e29c02047a493f15a78c0502bde4d3fab7c19c7813944d367cd501811c/grpcio-1.84.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:158c1c11cfb61b4849c3caf4d52de6f5ecd376e14446feb4a90dc95a90d616f5", size = 7029927, upload-time = "2026-09-14T06:57:19.767Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/11/9962b313553647abb091943e0721e4a1662ecc63cdfe930abf00abcce47a/grpcio-1.84.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:a9383401d9f116f98cacd4eba6c505a6edb80ba65badfc8e8ed8ae64983bcc44", size = 7782268, upload-time = "2026-09-14T06:57:22.381Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14a9413cb7d4b2e782b4f79c81a918610caedf55138ab5916f5fdd4b002f/grpcio-1.84.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd8ea8eb3817b226057cc1c0e7ec4b378dcda52043b972b6ff12b1152178967d", size = 7187959, upload-time = "2026-09-14T06:57:24.686Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/3b/6cc8e6aed8f23be40f52af341e5d4595ec3ec8d7572271a692b5c1212178/grpcio-1.84.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:756ea5c2da00fa65c930284892d2a9706828704ca3ba40b4c51c4834eb39fcfd", size = 7737554, upload-time = "2026-09-14T06:57:27.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/7e/6f61002a01802ca9675e1b3599c9b0f9f3cf168ded94ebacc02199309f88/grpcio-1.84.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:28d2609691da93051e998495108bbddd2a9f7a561253bae94828d81290f30c15", size = 8792681, upload-time = "2026-09-14T06:57:29.731Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/84/8bec1ae7e6732a9b435a394ddfdfffde46c2620ae0109823f7cce1a54455/grpcio-1.84.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:27b8b36200a9fbee6e120246f4a8a41657549107ef19fb2c819c4b2fd524f39a", size = 8145493, upload-time = "2026-09-14T06:57:32.672Z" },
+    { url = "https://files.pythonhosted.org/packages/59/84/c8c7bd210d657288f18af06522f150f61e81ea14fd3c7c135beed697c5fd/grpcio-1.84.0-cp311-cp311-win32.whl", hash = "sha256:465eef3d17e59ad22a556fc0138f7c7c799df426734344daec42c797d49fda99", size = 4495596, upload-time = "2026-09-14T06:57:34.799Z" },
+    { url = "https://files.pythonhosted.org/packages/da/1e/da99356b3b573af357d059753a47fba54f1ca1a9c0e4deccd0210cb7f4ba/grpcio-1.84.0-cp311-cp311-win_amd64.whl", hash = "sha256:f9a456bdbed52a01c9ab8423bdebab04a5363c78676edc55ab9b58bd13bdf9e1", size = 5259900, upload-time = "2026-09-14T06:57:37.067Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/4c9a2e0e6b0aaf02781404cad2f79211f989f2c827cf672a4a48d1604d3e/grpcio-1.84.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:b5c6f20d657ae09ae4e30d9d3a21edd13f1219d58cc6f999b9d1bb63be9c1baa", size = 6415756, upload-time = "2026-09-14T06:57:39.345Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/57/131e7007bdee9acb77a8dbe8a16fa9fef75f88c1695242d8ee0993ac2d3d/grpcio-1.84.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:406583b4e8fb2282ebd392e12b963e601c1f82e07125a8c2cb5b144e7e024796", size = 12339195, upload-time = "2026-09-14T06:57:42.373Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d1/a7b7cda98fcab9b3d2916204a872d87371158a7a34e41768f524584fb64d/grpcio-1.84.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fbdbcd06986ede3ce584083b1dc2afe6808e8943e5cf50ad11183c03aceda25a", size = 6984468, upload-time = "2026-09-14T06:57:45.035Z" },
+    { url = "https://files.pythonhosted.org/packages/19/81/c5be83e3ac9416f73c4c51fe1ea9c41a0c42fc3509e3505faa46f5046abe/grpcio-1.84.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:23e6e8e8a75cff88e0a793bfd3becea03a13e2763ae90c1ff573bc19ca5b429a", size = 7749432, upload-time = "2026-09-14T06:57:47.395Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/bf/258cd7c0a7ed92745dc93c31666d462d05b702807a689744bd49fb833bde/grpcio-1.84.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b44f0a0fc7bc6677d38cc80bca1a32814ce6c8f200fb8b3c1a61c9d77eaefbf3", size = 7156115, upload-time = "2026-09-14T06:57:49.657Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/4b/7f829418dbfcf91b875e55e2973f1059a95decb4f081313416317ef04ec1/grpcio-1.84.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:210e4c32f907045eb8158273e60c6ab69a3947697df6245dbda381f26c59485b", size = 7708010, upload-time = "2026-09-14T06:57:52.496Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f0/9932e2fec6a04205f8bf3f8f4d2020479dcdac88feb6f93822ed31bf0eba/grpcio-1.84.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a71d24f40b0cc6798feaa978c7411dc1135b7018e9fc0442db611c139bf58344", size = 8759980, upload-time = "2026-09-14T06:57:55.312Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/5c/b67407c6dbc480dfc0715f6eccdb1061e7c88d85f9a330a241d357a538c5/grpcio-1.84.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f6c972474ce691aca74e58d17625450cef153dc4760364cadeb167983ea6d589", size = 8124904, upload-time = "2026-09-14T06:57:58.569Z" },
+    { url = "https://files.pythonhosted.org/packages/02/37/2bfdae2df8dfcfc0df619b628e0c7153ce703adae827243f44720322ccc1/grpcio-1.84.0-cp312-cp312-win32.whl", hash = "sha256:0d532ade4486dad9b302ffa4d4683d67561051c26d17c4023322845e9fa10140", size = 4478915, upload-time = "2026-09-14T06:58:00.714Z" },
+    { url = "https://files.pythonhosted.org/packages/85/2c/309268b7b39f6deb2342f634841e105623a0b67982e8b10ec516782ff1c6/grpcio-1.84.0-cp312-cp312-win_amd64.whl", hash = "sha256:49717e857899f4136d7657bf5aded61ac479110a075438290923a4d86af7cd02", size = 5253534, upload-time = "2026-09-14T06:58:03.336Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/51/40f99701adb01d4e5316a2aaf13838da1a24d5c879cd8c95156d7c364454/grpcio-1.84.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:209414080da8c20af94df1395b635da52dd57b5edc9e917e1deca0dc1c4bb55e", size = 6427619, upload-time = "2026-09-14T06:58:06.025Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/4b/ed8e22a1237e6b2be6ef4f221d074a5b0e0dd8a0da8c944c04aea731f0eb/grpcio-1.84.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:e41c3993eee896c617dbd8a505085d28b6e84a0445ed9a1f40f95808473cf678", size = 12336549, upload-time = "2026-09-14T06:58:08.583Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/50/00165b05cd73f45996748ea67ce9e55d08936f2fea94a7fd8541cc2d0e54/grpcio-1.84.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fff5ef3fe1bba7d6147e5f19e01e5e122ac2c076486887ddcb8d42e663400fbe", size = 6989458, upload-time = "2026-09-14T06:58:11.884Z" },
+    { url = "https://files.pythonhosted.org/packages/26/38/d0486230e684d916f97429a53041db88410e662a38f2a8d09e2d90375840/grpcio-1.84.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b8c62888c3e49debf37ad9773e3c02f77b0c1e811f8fb0962f2b6c3bbab5b97a", size = 7757778, upload-time = "2026-09-14T06:58:14.849Z" },
+    { url = "https://files.pythonhosted.org/packages/da/56/548a643decb059ca244499c675ae2c13a15f523ba94592c2774bd80a13c1/grpcio-1.84.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:986e9751d416d7a6eaa2fecdac38da63153d63a4b340ba7d624889c490451500", size = 7159572, upload-time = "2026-09-14T06:58:17.87Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f5/42caac81a79ec680f1f7a8eaf7ca90d2f93936ce0c3a073141ba96757f77/grpcio-1.84.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5933a052946873d01a42119a05420d669bdca436aeba2d1851988ccb12b421c0", size = 7710547, upload-time = "2026-09-14T06:58:20.607Z" },
+    { url = "https://files.pythonhosted.org/packages/57/a4/828ad990b2410fee0a55cc73aa1bf98eb5b911c54847374ef4f24b9e877b/grpcio-1.84.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e094dd21f077af8194923fc263cad872eaa1802bb0156fd7e5ae18e99cd86715", size = 8761519, upload-time = "2026-09-14T06:58:23.875Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a5/1f91af098919eaf5d80d5a61126ad9fae074e5190c25a3014ce1d8d0d890/grpcio-1.84.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08735e3d08d24ab3132cf87e2e5dea8746cabcc7d676c2b0b7362f195feef9d9", size = 8121424, upload-time = "2026-09-14T06:58:27.006Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/8f/77fd4a7a913b636785479922349c4cb98d94d05d15652e556b3ca0df6663/grpcio-1.84.0-cp313-cp313-win32.whl", hash = "sha256:70bb4ce8be0c5606bec259cbd7152374470396413b7863a658a08c849e6b29ff", size = 4477974, upload-time = "2026-09-14T06:58:29.528Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9a/1fa59ddbfc8898e5518d1447e46f771f387f0ed6132ad531395338e51a5c/grpcio-1.84.0-cp313-cp313-win_amd64.whl", hash = "sha256:b61692f0069b3eee2fc8a3a1b7f6c044df9e03fede6ce69b3ca832e1c39f26c5", size = 5255326, upload-time = "2026-09-14T06:58:31.781Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6f/e25ca89ca5b0b7b95464c907a5c21a77c0ac8c4ee1dca164c4dd8f153ddb/grpcio-1.84.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:026d757df86c5b7a41de8200b9a2cda454aaa5004cb0c7e3374c66eb82f61499", size = 6428207, upload-time = "2026-09-14T06:58:34.401Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/b4/6b76b429f3f9b901cdbc306c81364d708bc957f847a05cbd1046cd2d05d8/grpcio-1.84.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:3de427b05f244ba2c2a9bdc67e7a6731c8340811524ecc4435466549f8af1d17", size = 12342420, upload-time = "2026-09-14T06:58:37.416Z" },
+    { url = "https://files.pythonhosted.org/packages/af/64/ac86d638ba7f73bee0dccb608ba551d4f63adf75151f00d2c43e46d3979e/grpcio-1.84.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e90e3bdf7b5eac005fef631adae9cafde16f922def207b80a7c46b253c18ad20", size = 6998396, upload-time = "2026-09-14T06:58:40.535Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/fa12e9ec9d7ebf8cc3e81428fa9e1ca0d30d22d546ce2baa4c64bc917cbc/grpcio-1.84.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e88d304f094f4937bc27ec6a435e218a084168f11ec630c8d5d39b431d08d81d", size = 7757538, upload-time = "2026-09-14T06:58:43.297Z" },
+    { url = "https://files.pythonhosted.org/packages/21/d7/94240c7fae121ff1f116dcf04a3b7ee0216a06832c704310363f72638d4c/grpcio-1.84.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:57dc36a5ab0e676f5f6e171de2917fd0aef73f32a9aaf23956bfe19997a30bd1", size = 7161480, upload-time = "2026-09-14T06:58:45.939Z" },
+    { url = "https://files.pythonhosted.org/packages/23/c9/7033e95d4b344969818b09185721c7608b47fc2498d97b5e4eec4995dbf3/grpcio-1.84.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5deda5b4bf62769eb98c119cca43d40e1231e34846b19db5cdea821d446a2253", size = 7720191, upload-time = "2026-09-14T06:58:48.308Z" },
+    { url = "https://files.pythonhosted.org/packages/95/22/b45df2deba81d55069076859480bae7109c9eec02bce5515c799530cc2aa/grpcio-1.84.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9bab4cf571653a8afffb83ce21aa27b51dfe629b526b7b6adec35491fe1fc2ea", size = 8762792, upload-time = "2026-09-14T06:58:51.068Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c4/3e1c3d6155c16b8737cc31d5b477d6cf1fc7cdd10d58320cf0ec9b446f42/grpcio-1.84.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c5559b492007dc09b4de9b95dab05f0b5e53547aad230cf07e46c7dd017a3be5", size = 8123299, upload-time = "2026-09-14T06:58:54.332Z" },
+    { url = "https://files.pythonhosted.org/packages/56/fe/f4864de5b815e5ba18858771f99381a398fac14117f89ef5291ed43d3c4e/grpcio-1.84.0-cp314-cp314-win32.whl", hash = "sha256:2c024da73b296f040b8360e60bd73a659b230093684a438da0e1260f34cc724e", size = 4562560, upload-time = "2026-09-14T06:58:56.894Z" },
+    { url = "https://files.pythonhosted.org/packages/44/03/640811d4d8c84f5e603995c5a9bab725223aa472cad9ca4286c3bbf1c3e3/grpcio-1.84.0-cp314-cp314-win_amd64.whl", hash = "sha256:800b7e00d92553313c0463c200087930aa78678ec1d528193aeb50906f55989b", size = 5394092, upload-time = "2026-09-14T06:58:59.61Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/1a/9e3d2c9f005f680f03308fa894b1db91d4ab3f0fe65ff630c69561e91e95/grpcio-1.84.0-cp315-cp315-linux_armv7l.whl", hash = "sha256:47ecf0d9b81d981f07b61bd89eced9d2582f5eaacc3aaa36ad27f81aef70a27f", size = 6428252, upload-time = "2026-09-14T06:59:02.597Z" },
+    { url = "https://files.pythonhosted.org/packages/77/34/0bc9f52ebf091311651eeab3a452fb557985604a3088cb5406f4d6df85d3/grpcio-1.84.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:61386101ecaa096b694d0dd278caf99a56aeec78440cc17e918eef0b50f2d567", size = 12359488, upload-time = "2026-09-14T06:59:05.646Z" },
+    { url = "https://files.pythonhosted.org/packages/93/0e/c31052712f241cb6ecae9c226fabd519b7f8c64a7a40bac27e9ca0405b78/grpcio-1.84.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f6d178ba6dc8e82976c184b65fddde172d054c17237993a3e083efe4f134d55b", size = 7019339, upload-time = "2026-09-14T06:59:08.76Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b9/b9b33ea4f1eb4cad28833cade604febf357385b5ebb0c9c7562d020e167a/grpcio-1.84.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:15bb76489e337fc492685c9758e2fd4d4ab516b901ad830dc5a91987decf00be", size = 7107974, upload-time = "2026-09-14T06:59:11.568Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/9e/799d4c45db91bbdcd8c54b3982932dbcf3d059f7ce67dca3e8540faa1ece/grpcio-1.84.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82da34ae4f639c73ac46e521e00c0a49bf86f717b9fb1f405f133e98731e38dc", size = 7200036, upload-time = "2026-09-14T06:59:14.401Z" },
+    { url = "https://files.pythonhosted.org/packages/45/dc/dcfdd13ada41aff9098f0c2c6f260eb7debbc88b84b7e5fcbd085165427d/grpcio-1.84.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:9b73836ba0e16fcbb57c31cf6cbc2907c8d8c790b83679df454b74bd15e0be04", size = 7742281, upload-time = "2026-09-14T06:59:17.348Z" },
+    { url = "https://files.pythonhosted.org/packages/55/31/75eab2ec77b80804bc5e21cec99b57598e726fca6484cd3e8920a97639d5/grpcio-1.84.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:42959bd50dd660ffc3f2a9bec15a6da4f9aaa0dda555d59ff2d2e80b908456a8", size = 8113629, upload-time = "2026-09-14T06:59:20.584Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f0/fdcf6bdc1df9ca11679a1187bef8e6b81df31a2baae69497e17344f05ea3/grpcio-1.84.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:659728f20fc7a0933ed7b1945435e31014b97ab8a5a7edcbaa70da4794aeb191", size = 8152972, upload-time = "2026-09-14T06:59:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/cf/6720e720bfa80fcb1ace873f66724eb3c8b03bba2fa078a30c12cab3212e/grpcio-1.84.0-cp315-cp315-win32.whl", hash = "sha256:edb6f87fc60ff438557291501b3e16c7a77c3b01a52d782cf276dccc7c5dd89c", size = 4561981, upload-time = "2026-09-14T06:59:27.275Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/b9/69d8a709df225bc2e06e028e9465166b174c24b3da07cc72d9a5ddc63194/grpcio-1.84.0-cp315-cp315-win_amd64.whl", hash = "sha256:4119efa6519871719ad81f33bc95ab87857dcb1c5801f30a6e592f2c41164169", size = 5394757, upload-time = "2026-09-14T06:59:30.118Z" },
+]
+
+[[package]]
+name = "grpcio-reflection"
+version = "1.84.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "langchain-core" },
-    { name = "langgraph-checkpoint" },
+    { name = "grpcio" },
+    { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/57/30/f31f0e076c37d097b53e4cff5d479a3686e1991f6c86a1a4727d5d1f5489/langgraph_prebuilt-0.1.8.tar.gz", hash = "sha256:4de7659151829b2b955b6798df6800e580e617782c15c2c5b29b139697491831", size = 24543 }
+sdist = { url = "https://files.pythonhosted.org/packages/6e/8a/94af17ae0738cc4508af96d5f107f352e2b54473eecf32f0ed9bcdd895da/grpcio_reflection-1.84.0.tar.gz", hash = "sha256:06bf3d7d8cef9afbcc721ee52191652b4483831774255e174404b0e0551741bc", size = 19321, upload-time = "2026-09-14T07:10:28.58Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/72/9e092665502f8f52f2708065ed14fbbba3f95d1a1b65d62049b0c5fcdf00/langgraph_prebuilt-0.1.8-py3-none-any.whl", hash = "sha256:ae97b828ae00be2cefec503423aa782e1bff165e9b94592e224da132f2526968", size = 25903 },
+    { url = "https://files.pythonhosted.org/packages/47/8b/f07f5aa8ee2b2bd060c0100a581ab68a9b501a927fcf97b1855e40b7bd7c/grpcio_reflection-1.84.0-py3-none-any.whl", hash = "sha256:148b382a1a5621496ede90b12b97c868bb94f7bb8e23b18fc03ed32edd5447cb", size = 22986, upload-time = "2026-09-14T07:10:14.038Z" },
 ]
 
 [[package]]
-name = "langgraph-sdk"
-version = "0.1.69"
+name = "grpcio-tools"
+version = "1.84.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx" },
-    { name = "orjson" },
+    { name = "grpcio" },
+    { name = "protobuf" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/db/a5dba38d7ff7711d1ad05f2b43751bd0e9f234fae7c89df1846a9de034f9/grpcio_tools-1.84.0.tar.gz", hash = "sha256:210ac5ac9803569490ec33574b7e995bc087815b00d9b777e0134cab5ed9a379", size = 6401750, upload-time = "2026-09-14T07:03:45.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/db/57c19dd36921967f207a072b31c8b118a498077a224c4e611173b523df69/grpcio_tools-1.84.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:5157688cab3488d89ec986a6bbb0a9886ec655d4f854fd2c1099cf6d5be83646", size = 2652630, upload-time = "2026-09-14T07:01:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/af/2d/97d424455bc00e65a1fe6302b8b4cdd7a54d6699cf0a475a853f9b5d2008/grpcio_tools-1.84.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:48bd8ea0acfb7b15eb3f8fc28294ad9300bd10ab3d42a743a08f87506d9e5098", size = 5967266, upload-time = "2026-09-14T07:01:15.743Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/4f/85a020052de481403d47e69b770d5ac753cd75e4954668c13815f315af85/grpcio_tools-1.84.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7103c628a87f8dad1988ef951a66c9077866349053e4ae462bfbc9f91c7ad8f3", size = 2704488, upload-time = "2026-09-14T07:01:17.73Z" },
+    { url = "https://files.pythonhosted.org/packages/20/88/7ad7394ed55a825638f4ac9fae9b48d7e17735e9cf98ef72fdcfaf62da2d/grpcio_tools-1.84.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d1cafe92e8742188dae258dc20fb1133a35f9b09f80ef4e0368a558561b3a04c", size = 3032304, upload-time = "2026-09-14T07:01:19.46Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/54/9ac98578948edc3f5560b50cba0ec8ab6bb815926e636f3409509b55b2cc/grpcio_tools-1.84.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:036de16c1eb8e516740e0040e721fae73d459a5a5ca4dfb747b6cc095cf7a750", size = 2773921, upload-time = "2026-09-14T07:01:21.468Z" },
+    { url = "https://files.pythonhosted.org/packages/32/96/916f88c5884d8683bf01725c9840def4875c33f98f7cf6bcc9e82aae6044/grpcio_tools-1.84.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2643e748ce319fe75b703f42875dc42b203577f8e3e223d1ff73f37c7cfda748", size = 3226531, upload-time = "2026-09-14T07:01:23.775Z" },
+    { url = "https://files.pythonhosted.org/packages/70/25/9fde9350720ee37157989bab282fd6d330f4c4975ad19da72f2d3412346c/grpcio_tools-1.84.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fe0ef1f19790d7cefe563c4f533bb0a5b88135661e32aef7661e76a9f271d384", size = 3798916, upload-time = "2026-09-14T07:01:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/88/774f0ffa9abf36cef647440e76bec7ae1a35ecc4822dc59476c050d59d47/grpcio_tools-1.84.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ed58186650b7e7a6f48e6fc1aac2ec8440a72d4d7fc7cf2f6ae33878da7f2d6", size = 3457754, upload-time = "2026-09-14T07:01:27.831Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b7/69f71771d4e1bc67d4ff1c07c04b69d5d5a8424781129c4ca417c7f389ea/grpcio_tools-1.84.0-cp310-cp310-win32.whl", hash = "sha256:8d677c2beae4ab02d2ae4caf0241be18eed5301757b23f1544b133c6961c4035", size = 1022560, upload-time = "2026-09-14T07:01:29.654Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/8c/54bda326a2d283190f324d44d03195de4810595f7ba7ab5f3613cb63f1c1/grpcio_tools-1.84.0-cp310-cp310-win_amd64.whl", hash = "sha256:a2c00d4230c592dee120458352d846df083d7bc6198150f3b66a3005d586501e", size = 1192121, upload-time = "2026-09-14T07:01:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/81/62/518523308771b181cc836fe2533ffa65efeab84c7da23853240559b3959a/grpcio_tools-1.84.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:409de83da5c3526a3c8b8b880a8c4c6b23fa9b9f71a373e7f7c2c5f16ec8f30e", size = 2652835, upload-time = "2026-09-14T07:01:33.381Z" },
+    { url = "https://files.pythonhosted.org/packages/09/de/27bfd92c335182dd89609449f5bb51d6ee8849fa0d0a11215d3baf8f6e42/grpcio_tools-1.84.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8ece6d87168415125091fa74f7ddd1eb3e5dacd840052fa14b8c004d314798f1", size = 5967921, upload-time = "2026-09-14T07:01:35.844Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fe/675a69c7916c6c03cdf5a0c4dc43d2541f08bf33269b4f9bba59beab95c5/grpcio_tools-1.84.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4ac91151e7cf75a30af09aee29a9fc900e9d891323811da1a55ac985cbdbd33a", size = 2704869, upload-time = "2026-09-14T07:01:37.828Z" },
+    { url = "https://files.pythonhosted.org/packages/02/43/06ba2fda64118eef7691a948fee2fae37ab623a5b4ac2d44a5fc5e4ec50c/grpcio_tools-1.84.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:090c9310a90a63fb2c3c55adc75e35f37659eb2793eedd5951f7690aceff15c6", size = 3032321, upload-time = "2026-09-14T07:01:39.907Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2f/c2183306869d8a67c93047e65463b938991af63dcdd83e0204b36d994e18/grpcio_tools-1.84.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc99764d6091d0ec609277d0fdbbc70e9b4acca8f371b7157249162a2d7c0a11", size = 2774120, upload-time = "2026-09-14T07:01:42.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/33/649bc42798c523e67b568e7d95d4937a5d77701fa42808d80d12aeb779f1/grpcio_tools-1.84.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c54d4ab6c675efa1f5cedfbeb8f9ad3e69b1aee9e2a2b233c02d0e4cfa045ae0", size = 3226721, upload-time = "2026-09-14T07:01:44.602Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e0/982da24d9f3b055c671b4c8290a02af8bb361a2b405e34a907fda4cc4e98/grpcio_tools-1.84.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f99c5c5349ceff85a0f969281d14a5e9c3ec64cee4bc9af27047a58c1fd99c87", size = 3798997, upload-time = "2026-09-14T07:01:46.824Z" },
+    { url = "https://files.pythonhosted.org/packages/48/d5/298119f4c8035329031c687f43c607f6169208e71a1cc4861973c57a8065/grpcio_tools-1.84.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b71d9d1807948271e5d185267db972057d09aaf2d56b4233bc00a081297ef958", size = 3457776, upload-time = "2026-09-14T07:01:48.978Z" },
+    { url = "https://files.pythonhosted.org/packages/65/c2/37e211a88ab5e22875bab9543c508d206204f02359dde67cebf034154125/grpcio_tools-1.84.0-cp311-cp311-win32.whl", hash = "sha256:d704ef81507c7e86bf2dfed211b0d03758973240a9273f7ca7b577bc8a2a3084", size = 1022797, upload-time = "2026-09-14T07:01:50.873Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/dc/de9fc8567a95ba8448f430cba11195ed0ada811423c5a108e723f0cb39c0/grpcio_tools-1.84.0-cp311-cp311-win_amd64.whl", hash = "sha256:d96f12f3a4e5af091e7a3450de5f96825959b02720cd7d4732c992a97196540a", size = 1192474, upload-time = "2026-09-14T07:01:52.782Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f9/ad0fc599f687227569fb0f37695ad0b66b6c515ca4b938df863f1efb1109/grpcio_tools-1.84.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:bcc3b6f41e02d77e519e6e4f114f7ab5a22815acd9b6a3c8965417df36938de3", size = 2653285, upload-time = "2026-09-14T07:01:55.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/14/cc6e137a4fea4cf35b115c22e99be391b446ac002cd8742e8d97ecff5fd4/grpcio_tools-1.84.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:9315344bed77b08c155672ab2d77513e1e8a20fd2744ab0bb72647e22bc900ac", size = 5965932, upload-time = "2026-09-14T07:01:58.431Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7f/602dffdd92363c6b28959502eb97badcf28176c501e3f8a26d30d6893d31/grpcio_tools-1.84.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a83ccb3f47f841d92f04fd35ed1f8b094e2a92c33ae41f26732e970e0361ff14", size = 2705432, upload-time = "2026-09-14T07:02:00.882Z" },
+    { url = "https://files.pythonhosted.org/packages/55/1d/7a7bfd74fcf34d96995a05f03f9c01305f64982c6e53296363fe2d8f9911/grpcio_tools-1.84.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:9b0f4aa6fd1a72e2048742016da37cfa773394ee2b96daef6e6ef38a02eabea6", size = 3033412, upload-time = "2026-09-14T07:02:03.246Z" },
+    { url = "https://files.pythonhosted.org/packages/74/18/d9fa4b43c4974094a9e720e97fc90fcba1908f8c806b36eefabf6c148d88/grpcio_tools-1.84.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc1708de3ba6cc46eff02de1aea865442418167794ca963a2cf6ea2013930146", size = 2774501, upload-time = "2026-09-14T07:02:05.329Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/23/0458fb717829008b4c2160e37b2e4d6d7c31ad8c8b2ee411819f682a929e/grpcio_tools-1.84.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:45e38ee36a131ad1123b2741e045656419551efe52837a4702e09daee339fbcf", size = 3229874, upload-time = "2026-09-14T07:02:08.973Z" },
+    { url = "https://files.pythonhosted.org/packages/af/5a/e955b667d7fb2a8746f62342a108008798a333d3824b3d28b0c5d8034613/grpcio_tools-1.84.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a87275c13a9e6027d164494483027b9b08a8b9f6176108cb27d4bc13c8cbc720", size = 3803163, upload-time = "2026-09-14T07:02:12.006Z" },
+    { url = "https://files.pythonhosted.org/packages/08/fe/be66ea5d0962793156cc6e29da40e80a4f6ec12371564e6ba7237f8427e6/grpcio_tools-1.84.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:602453d5a04f74ead2077064249fc462bd4a93a1d23cb9f2c89cd254ac170ab7", size = 3461818, upload-time = "2026-09-14T07:02:14.099Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/32/9ecf7738075039348096a4cd739f0e994bbd28ef288f5bde68891739f22c/grpcio_tools-1.84.0-cp312-cp312-win32.whl", hash = "sha256:13a7e252569e3d2b3496fad5439a5f02f9f8d3454e66c5177fb3127342635c57", size = 1022489, upload-time = "2026-09-14T07:02:18.338Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2c/599ce7a1d0c9c232bde27d327d605d72f07437e0e665ca8153d499557367/grpcio_tools-1.84.0-cp312-cp312-win_amd64.whl", hash = "sha256:848338ebb0f1bccaf15c09d3905a2bda5907101ca2c88ed411c4ae707615f8ac", size = 1192285, upload-time = "2026-09-14T07:02:20.492Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/58/688e987d701d3673e6013adeb7c3d40f5886a79bc5fe3d2c462f13447cf3/grpcio_tools-1.84.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:7a34eee4038b8a92c4d2bd56ff6a68b7debb0e80fdd9a1f2dc77895525da2bc3", size = 2652846, upload-time = "2026-09-14T07:02:23.065Z" },
+    { url = "https://files.pythonhosted.org/packages/26/e9/fbc0a4d4234e7b7622bbeae07da6c4620a0baf2a9764f1d0728a12f0d2fd/grpcio_tools-1.84.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:131cc59f5612cc6d2b7f83adea3177eb85a0b52196007c555e7d80bb1d0b2b97", size = 5963562, upload-time = "2026-09-14T07:02:25.956Z" },
+    { url = "https://files.pythonhosted.org/packages/66/55/41dc86dd98fb5a8b620e47d2343030243bf80411d8da372ee1554c75b667/grpcio_tools-1.84.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b8c6d43a94a22a4a4630b112366fb01bebd4e3e2ac7519ee171268c8804f4e05", size = 2705097, upload-time = "2026-09-14T07:02:28.344Z" },
+    { url = "https://files.pythonhosted.org/packages/58/45/7a7c5e80a122990d61b0ff6603d3aaf1952de1faf4b2d2e7a6445d5bd894/grpcio_tools-1.84.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0130a41b311c5352fa7ab1e21da63b59db0af6559205d41c384099fc4c59f0be", size = 3033063, upload-time = "2026-09-14T07:02:30.636Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/a8/169ee6a6eb3225892c6be243452161b016f3bbd93fc555857dbb70d5939c/grpcio_tools-1.84.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fad2e65eed6e98ca01046bd8a47e446c7f760af89f2a958a497d61da203f9fd8", size = 2773655, upload-time = "2026-09-14T07:02:33.092Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/c1/41f67a4ce7c221810d515f7c384e2efbe3b547209b6686c018e9a4e54375/grpcio_tools-1.84.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:770f7c400339350e47abca5a874e5ddce9dfb313e9994af79af52482862bcb38", size = 3229788, upload-time = "2026-09-14T07:02:35.493Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/64/dcdfb115bfc0fa1c2659fa48c8b743cdb45d74c93d5e1a490665152ce068/grpcio_tools-1.84.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ee0609bc149bfe0b0e974ad2c3b30facc8fde16cb6c142ebaf9b5c3ffb428f97", size = 3802534, upload-time = "2026-09-14T07:02:38.172Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/47/2f36195b5c59cab8b8388c0e9d1383dfbc48a816db033789bd96692ab3d5/grpcio_tools-1.84.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cf4be6baf5f932950ec24c8ccd9284b6fa46e5b275aeb4789d7fe50a8452611", size = 3461034, upload-time = "2026-09-14T07:02:40.764Z" },
+    { url = "https://files.pythonhosted.org/packages/07/99/2956e79ccf82f225fe4e03835ff72bd673a95cd0e1541259b3964ffc2214/grpcio_tools-1.84.0-cp313-cp313-win32.whl", hash = "sha256:bd034763ecf817c3e97a9aeb1e5c5006389c06644973595af5f3a32a1e738c37", size = 1022115, upload-time = "2026-09-14T07:02:43.1Z" },
+    { url = "https://files.pythonhosted.org/packages/71/01/89a1d1f00801f892142ed31f28a2f325ce682b02bc294abf2ea8e951d205/grpcio_tools-1.84.0-cp313-cp313-win_amd64.whl", hash = "sha256:2d1e701bd77282618e76898b7dfe05094201c679ccb0b321fff2985d0fdb2e3f", size = 1191934, upload-time = "2026-09-14T07:02:45.829Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/a6b28ea267d0eb19d36543561bd38deb33cafa663c1b9aa78f83a3cb044f/grpcio_tools-1.84.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:b648d986c5465ea6b2df5457401bf5f27619394c889e688d6e67a453beb0db1e", size = 2652843, upload-time = "2026-09-14T07:02:48.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/64/3aa9f40934937acc73d18e241735ecf98e91e8522fb50308aa625238ee54/grpcio_tools-1.84.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:ce0d963308f1954c8265828b8aa0d37cdfebb068727fa34c700e992a64a0bdc6", size = 5963459, upload-time = "2026-09-14T07:02:50.822Z" },
+    { url = "https://files.pythonhosted.org/packages/87/6b/008c3e31e7681cacdc61ec0428f569f8ea959d48ed355c80ad9c748c743e/grpcio_tools-1.84.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a425e85bd95eb107f8a51baf717e265c4c37e1d0a31d57d7da6c7a1e302ffa5e", size = 2705302, upload-time = "2026-09-14T07:02:53.058Z" },
+    { url = "https://files.pythonhosted.org/packages/16/11/d8e17542a79c5a2645353e7cfe53b36a96bc3bf61d6502514eff997eac8c/grpcio_tools-1.84.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:259d3064dfced0b5439e26379f02a14cc696107fc488cb61bd0ebad09c76fa44", size = 3033047, upload-time = "2026-09-14T07:02:55.785Z" },
+    { url = "https://files.pythonhosted.org/packages/50/91/1bc18ec13f07fb77e1327cbbaeabbeb5dcf1cfe17fe8def9f4cd86fec4b4/grpcio_tools-1.84.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38b2819f6a04cb98158815f7d12cc14fd62659ce65c30b5c8c9f0efcf898cb6e", size = 2773834, upload-time = "2026-09-14T07:02:58.455Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/74/c6557d8928422a18d3a3e8522b67914d861026759243df28740cb1c515ce/grpcio_tools-1.84.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e4afaf1820c5a0c105538acf956cd2187b46b5438eb34f9b8e6257b674e97a67", size = 3229790, upload-time = "2026-09-14T07:03:01.779Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/63/02ba2c2866b6a18bd4d256aeccecfbc22908356cae9a659ba3e06fd0ee0e/grpcio_tools-1.84.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:1c76a4cee1dd0e4dfcd31e1024a69303296efdd1757173248d8c59bb64a1372b", size = 3802611, upload-time = "2026-09-14T07:03:04.581Z" },
+    { url = "https://files.pythonhosted.org/packages/80/95/350e3329b12e8fe775dda19c3f5c6e260af0f9bbb1165d11b7fb10a2d89f/grpcio_tools-1.84.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c47c6f708e2bf94503e31c578c904890225fd894a3f25f907fd3832f22b1c793", size = 3461325, upload-time = "2026-09-14T07:03:08.521Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/22/8463063fed0ead6c901f547d1cc7bd052391ef8eff4d1aa2e0f58f4a383c/grpcio_tools-1.84.0-cp314-cp314-win32.whl", hash = "sha256:daa0e3dff4feedbdfebc9192f2d714d5e37621b2466ba07070d002d1081a6e6f", size = 1045048, upload-time = "2026-09-14T07:03:10.723Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/41/4f7dd965ef2d72bc55ef208d0eadd73509aa7d4957a6eea5059a256ea01d/grpcio_tools-1.84.0-cp314-cp314-win_amd64.whl", hash = "sha256:a64a86d7e32d6ff57e0d4c6d01bac1ccd5718d01c5a5042b14ad63a00bd365f7", size = 1224203, upload-time = "2026-09-14T07:03:13.512Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d0/6cb3f84a4994a60929c2da21f5129cb04b675e814b3b03e4bbfc45512a2e/grpcio_tools-1.84.0-cp315-cp315-linux_armv7l.whl", hash = "sha256:ed27e0c12e687a4b15f6352e98eb794a296bdcc75fc26fbd5e2d1d6844c0bb5a", size = 2652855, upload-time = "2026-09-14T07:03:17.043Z" },
+    { url = "https://files.pythonhosted.org/packages/79/bf/0525cdfd7eb41feed328c3e839da12d56be9a23d87c74e15e1b16c3b2b5a/grpcio_tools-1.84.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:a30b3259bbcd7aa1377e8cf5e39b30962f88ead94bd1a25c30ab8819c1163a0d", size = 5971465, upload-time = "2026-09-14T07:03:20.057Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e3/ef3de0d88b69a022198ce1d8ff27df970f9bbf5f0f3d65576879054718e0/grpcio_tools-1.84.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b268a8cc6a0ffde0388371fee57942585060e89a3904eec1a2c00765707a26b3", size = 2707417, upload-time = "2026-09-14T07:03:22.826Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c4/f9c204a32145191bbcb39d487e2abcb9ed96c95e7d9e56267a1b5d378a61/grpcio_tools-1.84.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:feab5e59a8cbba38190196a29b878bedf3ea8e1baf94fe26fb21ca9a5b06e17c", size = 2904340, upload-time = "2026-09-14T07:03:25.8Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/54/a6d0aa5fc695e98c40442d9da819e2c178e3ee170182ff34922da512294b/grpcio_tools-1.84.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be960444736ff4363aad257847e0b6de8798a818b7760253b043f1c2141b522b", size = 2756591, upload-time = "2026-09-14T07:03:28.57Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/40/343a5fb15e9b702df619f34302829ae3f02306c6e22ce98a2634e5ee51d7/grpcio_tools-1.84.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:5c772fff61c94a526869fbbdc1cf5d40047170c0d591609685170130de031e63", size = 3231636, upload-time = "2026-09-14T07:03:31.285Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/1f/32445fe2f52f3e3fa1c83131f1c051d025baa1218e38fa51d7d3dab70248/grpcio_tools-1.84.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:769ae9073f09b2dd322b4de5e5fffa7c2f38340cf779a21486c45946ab2b2991", size = 3684445, upload-time = "2026-09-14T07:03:34.124Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/49/10314e948033f1f2c5a4d68edcade8795c5fab7cb4a132ae78d3cc98e300/grpcio_tools-1.84.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cee293333fc9efaa1e75d8baf0150d79007874c7bb364cffebf35346836038e8", size = 3435303, upload-time = "2026-09-14T07:03:37.42Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/69/69e92ff54e590236eff01ca72e9722ff31baac828c4bffcfac1f9a5e850d/grpcio_tools-1.84.0-cp315-cp315-win32.whl", hash = "sha256:65a2ae3836ffb7b035e341a6dcc81e3d8b090b0df173851715f44cdd89723b1e", size = 1045039, upload-time = "2026-09-14T07:03:39.731Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/8e/12b84ac60171f8401d31bf64e9cdf3e041653e3e5c79ce50cac7b2b8fa5d/grpcio_tools-1.84.0-cp315-cp315-win_amd64.whl", hash = "sha256:f28ffc8f0d2831a81239cee6b038ee3254bd7ac884fe69cc99b4ee83ff1fc1a5", size = 1224255, upload-time = "2026-09-14T07:03:42.561Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/78/4ca0603240332be5fc8ebbb9bc418896310643bef32e3319a311fab37e4c/langgraph_sdk-0.1.69.tar.gz", hash = "sha256:2e85d73b78a03f9606d0fafd62048b3060371149f6f9e61f07f087fd56c766fa", size = 45343 }
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/e6/8e82a0373e233392d83ae37f473c9799c536b307322f0caf49a59bce9522/langgraph_sdk-0.1.69-py3-none-any.whl", hash = "sha256:0ed117bcdf67285a17c57f6265f1d94f2dbd71346cf48a8e1a5fa25e523eb6b8", size = 48905 },
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
 ]
 
 [[package]]
-name = "langsmith"
-version = "0.3.42"
+name = "hatchling"
+version = "1.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx" },
-    { name = "orjson", marker = "platform_python_implementation != 'PyPy'" },
     { name = "packaging" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "requests-toolbelt" },
-    { name = "zstandard" },
+    { name = "pathspec" },
+    { name = "pluggy" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "trove-classifiers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/44/fe171c0b0fb0377b191aebf0b7779e0c7b2a53693c6a01ddad737212495d/langsmith-0.3.42.tar.gz", hash = "sha256:2b5cbc450ab808b992362aac6943bb1d285579aa68a3a8be901d30a393458f25", size = 345619 }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/9c/b4cfe330cd4f49cff17fd771154730555fa4123beb7f292cf0098b4e6c20/hatchling-1.29.0.tar.gz", hash = "sha256:793c31816d952cee405b83488ce001c719f325d9cda69f1fc4cd750527640ea6", size = 55656, upload-time = "2026-02-23T19:42:06.539Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/8e/e8a58e0abaae3f3ac4702e9ca35d1fc6159711556b64ffd0e247771a3f12/langsmith-0.3.42-py3-none-any.whl", hash = "sha256:18114327f3364385dae4026ebfd57d1c1cb46d8f80931098f0f10abe533475ff", size = 360334 },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/44032265776062a89171285ede55a0bdaadc8ac00f27f0512a71a9e3e1c8/hatchling-1.29.0-py3-none-any.whl", hash = "sha256:50af9343281f34785fab12da82e445ed987a6efb34fd8c2fc0f6e6630dbcc1b0", size = 76356, upload-time = "2026-02-23T19:42:05.197Z" },
 ]
 
 [[package]]
-name = "markupsafe"
-version = "3.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 },
-    { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 },
-    { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 },
-    { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 },
-    { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 },
-    { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 },
-    { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 },
-    { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 },
-    { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 },
-    { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 },
-    { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 },
-    { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 },
-    { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 },
-    { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 },
-    { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 },
-    { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 },
-    { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 },
-    { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 },
-    { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 },
-    { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 },
-]
-
-[[package]]
-name = "mcp"
-version = "1.8.1"
+name = "httpcore"
+version = "1.0.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
-    { name = "pydantic" },
-    { name = "pydantic-settings" },
-    { name = "python-multipart" },
-    { name = "sse-starlette" },
-    { name = "starlette" },
-    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+    { name = "certifi" },
+    { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7c/13/16b712e8a3be6a736b411df2fc6b4e75eb1d3e99b1cd57a3a1decf17f612/mcp-1.8.1.tar.gz", hash = "sha256:ec0646271d93749f784d2316fb5fe6102fb0d1be788ec70a9e2517e8f2722c0e", size = 265605 }
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/5d/91cf0d40e40ae9ecf8d4004e0f9611eea86085aa0b5505493e0ff53972da/mcp-1.8.1-py3-none-any.whl", hash = "sha256:948e03783859fa35abe05b9b6c0a1d5519be452fc079dc8d7f682549591c1770", size = 119761 },
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
 ]
 
 [[package]]
-name = "more-itertools"
-version = "10.7.0"
+name = "httpx"
+version = "0.28.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ce/a0/834b0cebabbfc7e311f30b46c8188790a37f89fc8d756660346fe5abfd09/more_itertools-10.7.0.tar.gz", hash = "sha256:9fddd5403be01a94b204faadcff459ec3568cf110265d3c54323e1e866ad29d3", size = 127671 }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/9f/7ba6f94fc1e9ac3d2b853fdff3035fb2fa5afbed898c4a72b8a020610594/more_itertools-10.7.0-py3-none-any.whl", hash = "sha256:d43980384673cb07d2f7d2d918c616b30c659c089ee23953f601d6609c67510e", size = 65278 },
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
 [[package]]
-name = "mypy"
-version = "1.15.0"
+name = "httpx-sse"
+version = "0.4.3"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mypy-extensions" },
-    { name = "typing-extensions" },
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 }
+
+[[package]]
+name = "identify"
+version = "2.6.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/c4/7fb4db12296cdb11893d61c92048fe617ee853f8523b9b296ac03b43757e/identify-2.6.18.tar.gz", hash = "sha256:873ac56a5e3fd63e7438a7ecbc4d91aca692eb3fefa4534db2b7913f3fc352fd", size = 99580, upload-time = "2026-03-15T18:39:50.319Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 },
-    { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 },
-    { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 },
-    { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 },
-    { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 },
-    { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 },
-    { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 },
+    { url = "https://files.pythonhosted.org/packages/46/33/92ef41c6fad0233e41d3d84ba8e8ad18d1780f1e5d99b3c683e6d7f98b63/identify-2.6.18-py2.py3-none-any.whl", hash = "sha256:8db9d3c8ea9079db92cafb0ebf97abdc09d52e97f4dcf773a2e694048b7cd737", size = 99394, upload-time = "2026-03-15T18:39:48.915Z" },
 ]
 
 [[package]]
-name = "mypy-extensions"
-version = "1.1.0"
+name = "idna"
+version = "3.15"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343 }
+sdist = { url = "https://files.pythonhosted.org/packages/82/77/7b3966d0b9d1d31a36ddf1746926a11dface89a83409bf1483f0237aa758/idna-3.15.tar.gz", hash = "sha256:ca962446ea538f7092a95e057da437618e886f4d349216d2b1e294abfdb65fdc", size = 199245, upload-time = "2026-05-12T22:45:57.011Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 },
+    { url = "https://files.pythonhosted.org/packages/d2/23/408243171aa9aaba178d3e2559159c24c1171a641aa83b67bdd3394ead8e/idna-3.15-py3-none-any.whl", hash = "sha256:048adeaf8c2d788c40fee287673ccaa74c24ffd8dcf09ffa555a2fbb59f10ac8", size = 72340, upload-time = "2026-05-12T22:45:55.733Z" },
 ]
 
 [[package]]
-name = "numpy"
-version = "2.2.5"
+name = "iniconfig"
+version = "2.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/b2/ce4b867d8cd9c0ee84938ae1e6a6f7926ebf928c9090d036fc3c6a04f946/numpy-2.2.5.tar.gz", hash = "sha256:a9c0d994680cd991b1cb772e8b297340085466a6fe964bc9d4e80f5e2f43c291", size = 20273920 }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/a0/0aa7f0f4509a2e07bd7a509042967c2fab635690d4f48c6c7b3afd4f448c/numpy-2.2.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:059b51b658f4414fff78c6d7b1b4e18283ab5fa56d270ff212d5ba0c561846f4", size = 20935102 },
-    { url = "https://files.pythonhosted.org/packages/7e/e4/a6a9f4537542912ec513185396fce52cdd45bdcf3e9d921ab02a93ca5aa9/numpy-2.2.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:47f9ed103af0bc63182609044b0490747e03bd20a67e391192dde119bf43d52f", size = 14191709 },
-    { url = "https://files.pythonhosted.org/packages/be/65/72f3186b6050bbfe9c43cb81f9df59ae63603491d36179cf7a7c8d216758/numpy-2.2.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:261a1ef047751bb02f29dfe337230b5882b54521ca121fc7f62668133cb119c9", size = 5149173 },
-    { url = "https://files.pythonhosted.org/packages/e5/e9/83e7a9432378dde5802651307ae5e9ea07bb72b416728202218cd4da2801/numpy-2.2.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4520caa3807c1ceb005d125a75e715567806fed67e315cea619d5ec6e75a4191", size = 6684502 },
-    { url = "https://files.pythonhosted.org/packages/ea/27/b80da6c762394c8ee516b74c1f686fcd16c8f23b14de57ba0cad7349d1d2/numpy-2.2.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d14b17b9be5f9c9301f43d2e2a4886a33b53f4e6fdf9ca2f4cc60aeeee76372", size = 14084417 },
-    { url = "https://files.pythonhosted.org/packages/aa/fc/ebfd32c3e124e6a1043e19c0ab0769818aa69050ce5589b63d05ff185526/numpy-2.2.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ba321813a00e508d5421104464510cc962a6f791aa2fca1c97b1e65027da80d", size = 16133807 },
-    { url = "https://files.pythonhosted.org/packages/bf/9b/4cc171a0acbe4666f7775cfd21d4eb6bb1d36d3a0431f48a73e9212d2278/numpy-2.2.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4cbdef3ddf777423060c6f81b5694bad2dc9675f110c4b2a60dc0181543fac7", size = 15575611 },
-    { url = "https://files.pythonhosted.org/packages/a3/45/40f4135341850df48f8edcf949cf47b523c404b712774f8855a64c96ef29/numpy-2.2.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54088a5a147ab71a8e7fdfd8c3601972751ded0739c6b696ad9cb0343e21ab73", size = 17895747 },
-    { url = "https://files.pythonhosted.org/packages/f8/4c/b32a17a46f0ffbde8cc82df6d3daeaf4f552e346df143e1b188a701a8f09/numpy-2.2.5-cp313-cp313-win32.whl", hash = "sha256:c8b82a55ef86a2d8e81b63da85e55f5537d2157165be1cb2ce7cfa57b6aef38b", size = 6309594 },
-    { url = "https://files.pythonhosted.org/packages/13/ae/72e6276feb9ef06787365b05915bfdb057d01fceb4a43cb80978e518d79b/numpy-2.2.5-cp313-cp313-win_amd64.whl", hash = "sha256:d8882a829fd779f0f43998e931c466802a77ca1ee0fe25a3abe50278616b1471", size = 12638356 },
-    { url = "https://files.pythonhosted.org/packages/79/56/be8b85a9f2adb688e7ded6324e20149a03541d2b3297c3ffc1a73f46dedb/numpy-2.2.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e8b025c351b9f0e8b5436cf28a07fa4ac0204d67b38f01433ac7f9b870fa38c6", size = 20963778 },
-    { url = "https://files.pythonhosted.org/packages/ff/77/19c5e62d55bff507a18c3cdff82e94fe174957bad25860a991cac719d3ab/numpy-2.2.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8dfa94b6a4374e7851bbb6f35e6ded2120b752b063e6acdd3157e4d2bb922eba", size = 14207279 },
-    { url = "https://files.pythonhosted.org/packages/75/22/aa11f22dc11ff4ffe4e849d9b63bbe8d4ac6d5fae85ddaa67dfe43be3e76/numpy-2.2.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:97c8425d4e26437e65e1d189d22dff4a079b747ff9c2788057bfb8114ce1e133", size = 5199247 },
-    { url = "https://files.pythonhosted.org/packages/4f/6c/12d5e760fc62c08eded0394f62039f5a9857f758312bf01632a81d841459/numpy-2.2.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:352d330048c055ea6db701130abc48a21bec690a8d38f8284e00fab256dc1376", size = 6711087 },
-    { url = "https://files.pythonhosted.org/packages/ef/94/ece8280cf4218b2bee5cec9567629e61e51b4be501e5c6840ceb593db945/numpy-2.2.5-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b4c0773b6ada798f51f0f8e30c054d32304ccc6e9c5d93d46cb26f3d385ab19", size = 14059964 },
-    { url = "https://files.pythonhosted.org/packages/39/41/c5377dac0514aaeec69115830a39d905b1882819c8e65d97fc60e177e19e/numpy-2.2.5-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55f09e00d4dccd76b179c0f18a44f041e5332fd0e022886ba1c0bbf3ea4a18d0", size = 16121214 },
-    { url = "https://files.pythonhosted.org/packages/db/54/3b9f89a943257bc8e187145c6bc0eb8e3d615655f7b14e9b490b053e8149/numpy-2.2.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:02f226baeefa68f7d579e213d0f3493496397d8f1cff5e2b222af274c86a552a", size = 15575788 },
-    { url = "https://files.pythonhosted.org/packages/b1/c4/2e407e85df35b29f79945751b8f8e671057a13a376497d7fb2151ba0d290/numpy-2.2.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c26843fd58f65da9491165072da2cccc372530681de481ef670dcc8e27cfb066", size = 17893672 },
-    { url = "https://files.pythonhosted.org/packages/29/7e/d0b44e129d038dba453f00d0e29ebd6eaf2f06055d72b95b9947998aca14/numpy-2.2.5-cp313-cp313t-win32.whl", hash = "sha256:1a161c2c79ab30fe4501d5a2bbfe8b162490757cf90b7f05be8b80bc02f7bb8e", size = 6377102 },
-    { url = "https://files.pythonhosted.org/packages/63/be/b85e4aa4bf42c6502851b971f1c326d583fcc68227385f92089cf50a7b45/numpy-2.2.5-cp313-cp313t-win_amd64.whl", hash = "sha256:d403c84991b5ad291d3809bace5e85f4bbf44a04bdc9a88ed2bb1807b3360bb8", size = 12750096 },
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
 [[package]]
-name = "opentelemetry-api"
-version = "1.33.0"
+name = "itk-python-v10-agent"
+version = "0.1.0"
+source = { virtual = "itk" }
+dependencies = [
+    { name = "a2a-sdk", extra = ["grpc", "http-server", "sqlite"] },
+    { name = "fastapi" },
+    { name = "grpcio" },
+    { name = "grpcio-tools" },
+    { name = "httpx-sse" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "sse-starlette" },
+    { name = "uvicorn" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "a2a-sdk", extras = ["sqlite", "grpc", "http-server"], editable = "." },
+    { name = "fastapi" },
+    { name = "grpcio" },
+    { name = "grpcio-tools" },
+    { name = "httpx-sse" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "sse-starlette" },
+    { name = "uvicorn" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "deprecated" },
-    { name = "importlib-metadata" },
+    { name = "markupsafe" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/ca/920a73b4a11cd271ba1c62f34dba27d7783996a6a7ac0bac7c83b230736d/opentelemetry_api-1.33.0.tar.gz", hash = "sha256:cc4380fd2e6da7dcb52a828ea81844ed1f4f2eb638ca3c816775109d93d58ced", size = 65000 }
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/c4/26c7ec8e51c19632f42503dbabed286c261fb06f8f61ffd348690e36958a/opentelemetry_api-1.33.0-py3-none-any.whl", hash = "sha256:158df154f628e6615b65fdf6e59f99afabea7213e72c5809dd4adf06c0d997cd", size = 65772 },
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
 ]
 
 [[package]]
-name = "opentelemetry-exporter-gcp-trace"
-version = "1.9.0"
+name = "json-rpc"
+version = "1.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/9e/59f4a5b7855ced7346ebf40a2e9a8942863f644378d956f68bcef2c88b90/json-rpc-1.15.0.tar.gz", hash = "sha256:e6441d56c1dcd54241c937d0a2dcd193bdf0bdc539b5316524713f554b7f85b9", size = 28854, upload-time = "2023-06-11T09:45:49.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/9e/820c4b086ad01ba7d77369fb8b11470a01fac9b4977f02e18659cf378b6b/json_rpc-1.15.0-py2.py3-none-any.whl", hash = "sha256:4a4668bbbe7116feb4abbd0f54e64a4adcf4b8f648f19ffa0848ad0f6606a9bf", size = 39450, upload-time = "2023-06-11T09:45:47.136Z" },
+]
+
+[[package]]
+name = "mako"
+version = "1.3.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "google-cloud-trace" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-resourcedetector-gcp" },
-    { name = "opentelemetry-sdk" },
+    { name = "markupsafe" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/15/7556d54b01fb894497f69a98d57faa9caa45ffa59896e0bba6847a7f0d15/opentelemetry_exporter_gcp_trace-1.9.0.tar.gz", hash = "sha256:c3fc090342f6ee32a0cc41a5716a6bb716b4422d19facefcb22dc4c6b683ece8", size = 18568 }
+sdist = { url = "https://files.pythonhosted.org/packages/00/62/791b31e69ae182791ec67f04850f2f062716bbd205483d63a215f3e062d3/mako-1.3.12.tar.gz", hash = "sha256:9f778e93289bd410bb35daadeb4fc66d95a746f0b75777b942088b7fd7af550a", size = 400219, upload-time = "2026-04-28T19:01:08.512Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/cd/6d7fbad05771eb3c2bace20f6360ce5dac5ca751c6f2122853e43830c32e/opentelemetry_exporter_gcp_trace-1.9.0-py3-none-any.whl", hash = "sha256:0a8396e8b39f636eeddc3f0ae08ddb40c40f288bc8c5544727c3581545e77254", size = 13973 },
+    { url = "https://files.pythonhosted.org/packages/bc/b1/a0ec7a5a9db730a08daef1fdfb8090435b82465abbf758a596f0ea88727e/mako-1.3.12-py3-none-any.whl", hash = "sha256:8f61569480282dbf557145ce441e4ba888be453c30989f879f0d652e39f53ea9", size = 78521, upload-time = "2026-04-28T19:01:10.393Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
 ]
 
 [[package]]
-name = "opentelemetry-resourcedetector-gcp"
-version = "1.9.0a0"
+name = "opentelemetry-api"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-sdk" },
-    { name = "requests" },
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/86/f0693998817779802525a5bcc885a3cdb68d05b636bc6faae5c9ade4bee4/opentelemetry_resourcedetector_gcp-1.9.0a0.tar.gz", hash = "sha256:6860a6649d1e3b9b7b7f09f3918cc16b72aa0c0c590d2a72ea6e42b67c9a42e7", size = 20730 }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/04/7e33228c88422a5518e1774a836c9ec68f10f51bde0f1d5dd5f3054e612a/opentelemetry_resourcedetector_gcp-1.9.0a0-py3-none-any.whl", hash = "sha256:4e5a0822b0f0d7647b7ceb282d7aa921dd7f45466540bd0a24f954f90db8fde8", size = 20378 },
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.33.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/37/0a/b7ae406175a2798a767e12db223e842911d9c398eea100c41c989afd2aa8/opentelemetry_sdk-1.33.0.tar.gz", hash = "sha256:a7fc56d1e07b218fcc316b24d21b59d3f1967b2ca22c217b05da3a26b797cc68", size = 161381 }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/34/831f5d9ae9375c9ba2446cb3cc0be79d8d73b78f813c9567e1615c2624f6/opentelemetry_sdk-1.33.0-py3-none-any.whl", hash = "sha256:bed376b6d37fbf00688bb65edfee817dd01d48b8559212831437529a6066049a", size = 118861 },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.54b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "deprecated" },
     { name = "opentelemetry-api" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/92/8c/bc970d1599ff40b7913c953a95195addf11c81a27cc85d5ed568e9f8c57f/opentelemetry_semantic_conventions-0.54b0.tar.gz", hash = "sha256:467b739977bdcb079af1af69f73632535cdb51099d5e3c5709a35d10fe02a9c9", size = 118646 }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/aa/f7c46c19aee189e0123ef7209eaafc417e242b2073485dfb40523d6d8612/opentelemetry_semantic_conventions-0.54b0-py3-none-any.whl", hash = "sha256:fad7c1cf8908fd449eb5cf9fbbeefb301acf4bc995101f85277899cec125d823", size = 194937 },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
-name = "orjson"
-version = "3.10.18"
+name = "outcome"
+version = "1.3.0.post0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/81/0b/fea456a3ffe74e70ba30e01ec183a9b26bec4d497f61dcfce1b601059c60/orjson-3.10.18.tar.gz", hash = "sha256:e8da3947d92123eda795b68228cafe2724815621fe35e8e320a9e9593a4bcd53", size = 5422810 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/f0/8aedb6574b68096f3be8f74c0b56d36fd94bcf47e6c7ed47a7bd1474aaa8/orjson-3.10.18-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:69c34b9441b863175cc6a01f2935de994025e773f814412030f269da4f7be147", size = 249087 },
-    { url = "https://files.pythonhosted.org/packages/bc/f7/7118f965541aeac6844fcb18d6988e111ac0d349c9b80cda53583e758908/orjson-3.10.18-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:1ebeda919725f9dbdb269f59bc94f861afbe2a27dce5608cdba2d92772364d1c", size = 133273 },
-    { url = "https://files.pythonhosted.org/packages/fb/d9/839637cc06eaf528dd8127b36004247bf56e064501f68df9ee6fd56a88ee/orjson-3.10.18-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5adf5f4eed520a4959d29ea80192fa626ab9a20b2ea13f8f6dc58644f6927103", size = 136779 },
-    { url = "https://files.pythonhosted.org/packages/2b/6d/f226ecfef31a1f0e7d6bf9a31a0bbaf384c7cbe3fce49cc9c2acc51f902a/orjson-3.10.18-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7592bb48a214e18cd670974f289520f12b7aed1fa0b2e2616b8ed9e069e08595", size = 132811 },
-    { url = "https://files.pythonhosted.org/packages/73/2d/371513d04143c85b681cf8f3bce743656eb5b640cb1f461dad750ac4b4d4/orjson-3.10.18-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f872bef9f042734110642b7a11937440797ace8c87527de25e0c53558b579ccc", size = 137018 },
-    { url = "https://files.pythonhosted.org/packages/69/cb/a4d37a30507b7a59bdc484e4a3253c8141bf756d4e13fcc1da760a0b00cb/orjson-3.10.18-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0315317601149c244cb3ecef246ef5861a64824ccbcb8018d32c66a60a84ffbc", size = 138368 },
-    { url = "https://files.pythonhosted.org/packages/1e/ae/cd10883c48d912d216d541eb3db8b2433415fde67f620afe6f311f5cd2ca/orjson-3.10.18-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0da26957e77e9e55a6c2ce2e7182a36a6f6b180ab7189315cb0995ec362e049", size = 142840 },
-    { url = "https://files.pythonhosted.org/packages/6d/4c/2bda09855c6b5f2c055034c9eda1529967b042ff8d81a05005115c4e6772/orjson-3.10.18-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb70d489bc79b7519e5803e2cc4c72343c9dc1154258adf2f8925d0b60da7c58", size = 133135 },
-    { url = "https://files.pythonhosted.org/packages/13/4a/35971fd809a8896731930a80dfff0b8ff48eeb5d8b57bb4d0d525160017f/orjson-3.10.18-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e9e86a6af31b92299b00736c89caf63816f70a4001e750bda179e15564d7a034", size = 134810 },
-    { url = "https://files.pythonhosted.org/packages/99/70/0fa9e6310cda98365629182486ff37a1c6578e34c33992df271a476ea1cd/orjson-3.10.18-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:c382a5c0b5931a5fc5405053d36c1ce3fd561694738626c77ae0b1dfc0242ca1", size = 413491 },
-    { url = "https://files.pythonhosted.org/packages/32/cb/990a0e88498babddb74fb97855ae4fbd22a82960e9b06eab5775cac435da/orjson-3.10.18-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8e4b2ae732431127171b875cb2668f883e1234711d3c147ffd69fe5be51a8012", size = 153277 },
-    { url = "https://files.pythonhosted.org/packages/92/44/473248c3305bf782a384ed50dd8bc2d3cde1543d107138fd99b707480ca1/orjson-3.10.18-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d808e34ddb24fc29a4d4041dcfafbae13e129c93509b847b14432717d94b44f", size = 137367 },
-    { url = "https://files.pythonhosted.org/packages/ad/fd/7f1d3edd4ffcd944a6a40e9f88af2197b619c931ac4d3cfba4798d4d3815/orjson-3.10.18-cp313-cp313-win32.whl", hash = "sha256:ad8eacbb5d904d5591f27dee4031e2c1db43d559edb8f91778efd642d70e6bea", size = 142687 },
-    { url = "https://files.pythonhosted.org/packages/4b/03/c75c6ad46be41c16f4cfe0352a2d1450546f3c09ad2c9d341110cd87b025/orjson-3.10.18-cp313-cp313-win_amd64.whl", hash = "sha256:aed411bcb68bf62e85588f2a7e03a6082cc42e5a2796e06e72a962d7c6310b52", size = 134794 },
-    { url = "https://files.pythonhosted.org/packages/c2/28/f53038a5a72cc4fd0b56c1eafb4ef64aec9685460d5ac34de98ca78b6e29/orjson-3.10.18-cp313-cp313-win_arm64.whl", hash = "sha256:f54c1385a0e6aba2f15a40d703b858bedad36ded0491e55d35d905b2c34a4cc3", size = 131186 },
+dependencies = [
+    { name = "attrs" },
 ]
-
-[[package]]
-name = "ormsgpack"
-version = "1.9.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/25/a7/462cf8ff5e29241868b82d3a5ec124d690eb6a6a5c6fa5bb1367b839e027/ormsgpack-1.9.1.tar.gz", hash = "sha256:3da6e63d82565e590b98178545e64f0f8506137b92bd31a2d04fd7c82baf5794", size = 56887 }
+sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060, upload-time = "2023-10-26T04:26:04.361Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/54/0390d5d092831e4df29dbafe32402891fc14b3e6ffe5a644b16cbbc9d9bc/ormsgpack-1.9.1-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:ac61c18d9dd085e8519b949f7e655f7fb07909fd09c53b4338dd33309012e289", size = 383226 },
-    { url = "https://files.pythonhosted.org/packages/47/64/8b15d262d1caefead8fb22ec144f5ff7d9505fc31c22bc34598053d46fbe/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134840b8c6615da2c24ce77bd12a46098015c808197a9995c7a2d991e1904eec", size = 214057 },
-    { url = "https://files.pythonhosted.org/packages/57/00/65823609266bad4d5ed29ea753d24a3bdb01c7edaf923da80967fc31f9c5/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38fd42618f626394b2c7713c5d4bcbc917254e9753d5d4cde460658b51b11a74", size = 217340 },
-    { url = "https://files.pythonhosted.org/packages/a0/51/e535c50f7f87b49110233647f55300d7975139ef5e51f1adb4c55f58c124/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d36397333ad07b9eba4c2e271fa78951bd81afc059c85a6e9f6c0eb2de07cda", size = 223815 },
-    { url = "https://files.pythonhosted.org/packages/0c/ee/393e4a6de2a62124bf589602648f295a9fb3907a0e2fe80061b88899d072/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:603063089597917d04e4c1b1d53988a34f7dc2ff1a03adcfd1cf4ae966d5fba6", size = 394287 },
-    { url = "https://files.pythonhosted.org/packages/c6/d8/e56d7c3cb73a0e533e3e2a21ae5838b2aa36a9dac1ca9c861af6bae5a369/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:94bbf2b185e0cb721ceaba20e64b7158e6caf0cecd140ca29b9f05a8d5e91e2f", size = 480707 },
-    { url = "https://files.pythonhosted.org/packages/e6/e0/6a3c6a6dc98583a721c54b02f5195bde8f801aebdeda9b601fa2ab30ad39/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c38f380b1e8c96a712eb302b9349347385161a8e29046868ae2bfdfcb23e2692", size = 397246 },
-    { url = "https://files.pythonhosted.org/packages/b0/60/0ee5d790f13507e1f75ac21fc82dc1ef29afe1f520bd0f249d65b2f4839b/ormsgpack-1.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:a4bc63fb30db94075611cedbbc3d261dd17cf2aa8ff75a0fd684cd45ca29cb1b", size = 125371 },
+    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692, upload-time = "2023-10-26T04:26:02.532Z" },
 ]
 
 [[package]]
 name = "packaging"
-version = "24.2"
+version = "26.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
 ]
 
 [[package]]
 name = "pathspec"
-version = "0.12.1"
+version = "1.0.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
 ]
 
 [[package]]
 name = "platformdirs"
-version = "4.3.8"
+version = "4.9.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362 }
+sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567 },
+    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
 ]
 
 [[package]]
 name = "pluggy"
-version = "1.5.0"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+    { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" },
 ]
 
 [[package]]
 name = "proto-plus"
-version = "1.26.1"
+version = "1.28.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/ac/87285f15f7cce6d4a008f33f1757fb5a13611ea8914eb58c3d0d26243468/proto_plus-1.26.1.tar.gz", hash = "sha256:21a515a4c4c0088a773899e23c7bbade3d18f9c66c73edd4c7ee3816bc96a012", size = 56142 }
+sdist = { url = "https://files.pythonhosted.org/packages/40/a6/4fbadcc2044034449b3f8f0ce82dcf3005d53f37c136642103fd4836a31c/proto_plus-1.28.4.tar.gz", hash = "sha256:5ff7ecad828e032a491fcb86947801768e32237f99dd049b649965b892ae9a63", size = 58679, upload-time = "2026-08-25T19:19:15.102Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/6d/280c4c2ce28b1593a19ad5239c8b826871fc6ec275c21afc8e1820108039/proto_plus-1.26.1-py3-none-any.whl", hash = "sha256:13285478c2dcf2abb829db158e1047e2f1e8d63a077d94263c2b88b043c75a66", size = 50163 },
+    { url = "https://files.pythonhosted.org/packages/41/5d/0f04b85dafdc3250ced7f2592efc17dce7f40712e941e9632202481e600d/proto_plus-1.28.4-py3-none-any.whl", hash = "sha256:4b01341272f8a348db3f003b6143109f83ab43091019d5181b3fcdf500ab32aa", size = 50797, upload-time = "2026-08-25T19:18:12.338Z" },
 ]
 
 [[package]]
 name = "protobuf"
-version = "5.29.4"
+version = "7.36.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/17/7d/b9dca7365f0e2c4fa7c193ff795427cfa6290147e5185ab11ece280a18e7/protobuf-5.29.4.tar.gz", hash = "sha256:4f1dfcd7997b31ef8f53ec82781ff434a28bf71d9102ddde14d076adcfc78c99", size = 424902 }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/b2/043a1a1a20edd134563699b0e91862726a0dc9146c090743b6c44d798e75/protobuf-5.29.4-cp310-abi3-win32.whl", hash = "sha256:13eb236f8eb9ec34e63fc8b1d6efd2777d062fa6aaa68268fb67cf77f6839ad7", size = 422709 },
-    { url = "https://files.pythonhosted.org/packages/79/fc/2474b59570daa818de6124c0a15741ee3e5d6302e9d6ce0bdfd12e98119f/protobuf-5.29.4-cp310-abi3-win_amd64.whl", hash = "sha256:bcefcdf3976233f8a502d265eb65ea740c989bacc6c30a58290ed0e519eb4b8d", size = 434506 },
-    { url = "https://files.pythonhosted.org/packages/46/de/7c126bbb06aa0f8a7b38aaf8bd746c514d70e6a2a3f6dd460b3b7aad7aae/protobuf-5.29.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:307ecba1d852ec237e9ba668e087326a67564ef83e45a0189a772ede9e854dd0", size = 417826 },
-    { url = "https://files.pythonhosted.org/packages/a2/b5/bade14ae31ba871a139aa45e7a8183d869efe87c34a4850c87b936963261/protobuf-5.29.4-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:aec4962f9ea93c431d5714ed1be1c93f13e1a8618e70035ba2b0564d9e633f2e", size = 319574 },
-    { url = "https://files.pythonhosted.org/packages/46/88/b01ed2291aae68b708f7d334288ad5fb3e7aa769a9c309c91a0d55cb91b0/protobuf-5.29.4-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:d7d3f7d1d5a66ed4942d4fefb12ac4b14a29028b209d4bfb25c68ae172059922", size = 319672 },
-    { url = "https://files.pythonhosted.org/packages/12/fb/a586e0c973c95502e054ac5f81f88394f24ccc7982dac19c515acd9e2c93/protobuf-5.29.4-py3-none-any.whl", hash = "sha256:3fde11b505e1597f71b875ef2fc52062b6a9740e5f7c8997ce878b6009145862", size = 172551 },
+    { url = "https://files.pythonhosted.org/packages/32/72/98342feb672507c8f3a69e34b4fa8961f608edba5c1a48a6f47156d92cb5/protobuf-7.36.2-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:cbc70b17ee27e28894c7fee8bb04be1abead49e936bc70eb60052531eee2079e", size = 456039, upload-time = "2026-09-17T20:07:51.542Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ea/91fdf7c2b8bbd49cde056f00a9df6773532987e1c00fe2830b895af95c7e/protobuf-7.36.2-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:e11e1f0180583a2af89db6a2ecd9e8dc40aa6d2988ca175bfd0e6d12ea72d74e", size = 344219, upload-time = "2026-09-17T20:07:52.914Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ab/5fd5f8ece73fad885c5a09aa849b32d70472f954ba3a92d3bb5974ea953b/protobuf-7.36.2-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:f4fee11ec330d238b34a05c9b675f693c20415d1c5bd7d5320cc2f8a798eb9cf", size = 357223, upload-time = "2026-09-17T20:07:53.985Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/1b/dcc64f358fcb51811b58ae40b3d28f820725f116d86487cc20bd4b130701/protobuf-7.36.2-cp310-abi3-win32.whl", hash = "sha256:912c1221170e16c08d1f086762f563dd61ff83c18b5fa6652952dfaded66f728", size = 442998, upload-time = "2026-09-17T20:07:55.826Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/55/b77bda4e5e5f5971fb51b07663694690e9afdb9402136c16a522bd621cad/protobuf-7.36.2-cp310-abi3-win_amd64.whl", hash = "sha256:a300819d441e078a5608c0d3c709796bb548136058fda017ae51d425b44fd353", size = 456514, upload-time = "2026-09-17T20:07:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" },
 ]
 
 [[package]]
 name = "pyasn1"
-version = "0.6.1"
+version = "0.6.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322 }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/9a/23310166d960def5897e91fe20e5b724601b02a22e84ba1f94232c0b7f67/pyasn1-0.6.4.tar.gz", hash = "sha256:9c447d8431c947fe4c8febc4ed9e760bc29011a5b01e5c74b67025bd9fb8ce81", size = 151262, upload-time = "2026-07-09T01:12:33.988Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135 },
+    { url = "https://files.pythonhosted.org/packages/9a/3b/6163796d69c3977d1e4287bea4a6979161cbbdd170ebb430511e8e1999ce/pyasn1-0.6.4-py3-none-any.whl", hash = "sha256:deda9277cfd454080ec40b207fb6df82206a3a2688735233cdcd8d3d565f088b", size = 84410, upload-time = "2026-07-09T01:12:32.92Z" },
 ]
 
 [[package]]
@@ -1405,188 +1485,346 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pyasn1" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892 }
+sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259 },
+    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
 ]
 
 [[package]]
 name = "pycparser"
-version = "2.22"
+version = "3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
 ]
 
 [[package]]
 name = "pydantic"
-version = "2.11.4"
+version = "2.13.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
     { name = "pydantic-core" },
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/77/ab/5250d56ad03884ab5efd07f734203943c8a8ab40d551e208af81d0257bf2/pydantic-2.11.4.tar.gz", hash = "sha256:32738d19d63a226a52eed76645a98ee07c1f410ee41d93b4afbfa85ed8111c2d", size = 786540 }
+sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e7/12/46b65f3534d099349e38ef6ec98b1a5a81f42536d17e0ba382c28c67ba67/pydantic-2.11.4-py3-none-any.whl", hash = "sha256:d9615eaa9ac5a063471da949c8fc16376a84afb5024688b3ff885693506764eb", size = 443900 },
+    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
 ]
 
 [[package]]
 name = "pydantic-core"
-version = "2.33.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688 },
-    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808 },
-    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580 },
-    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859 },
-    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810 },
-    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498 },
-    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611 },
-    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924 },
-    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196 },
-    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389 },
-    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223 },
-    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473 },
-    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269 },
-    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921 },
-    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162 },
-    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560 },
-    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777 },
-]
-
-[[package]]
-name = "pydantic-settings"
-version = "2.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/67/1d/42628a2c33e93f8e9acbde0d5d735fa0850f3e6a2f8cb1eb6c40b9a732ac/pydantic_settings-2.9.1.tar.gz", hash = "sha256:c509bf79d27563add44e8446233359004ed85066cd096d8b510f715e6ef5d268", size = 163234 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/5f/d6d641b490fd3ec2c4c13b4244d68deea3a1b970a97be64f34fb5504ff72/pydantic_settings-2.9.1-py3-none-any.whl", hash = "sha256:59b4f431b1defb26fe620c71a7d3968a710d719f5f4cdbbdb7926edeb770f6ef", size = 44356 },
-]
-
-[[package]]
-name = "pyparsing"
-version = "3.2.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120 },
+version = "2.46.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/08/f1ba952f1c8ae5581c70fa9c6da89f247b83e3dd8c09c035d5d7931fc23d/pydantic_core-2.46.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4", size = 2113146, upload-time = "2026-05-06T13:37:36.537Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c6/65f646c7ff09bd257f660434adb45c4dfcbbcebcc030562fecf6f5bf887d/pydantic_core-2.46.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5", size = 1949769, upload-time = "2026-05-06T13:37:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ba/bfb1d928fd5b49e1258935ff104ae356e9fd89384a55bf9f847e9193ad40/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba", size = 1974958, upload-time = "2026-05-06T13:37:28.611Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/74/76223bfb117b64af743c9b6670d1364516f5c0604f96b48f3272f6af6cc6/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b", size = 2042118, upload-time = "2026-05-06T13:36:55.216Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/7b/848732968bc8f48f3187542f08358b9d842db564147b256669426ebb1652/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c", size = 2222876, upload-time = "2026-05-06T13:38:25.455Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/e90b63ee2e14bd8d3db8f705a6d75d64e6ee1b7c2c8833747ce706e1e0ce/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50", size = 2286703, upload-time = "2026-05-06T13:37:53.304Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/1e/acc4d70f88a0a277e4a1fa77ebb985ceabaf900430f875bf9338e11c9420/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd", size = 2092042, upload-time = "2026-05-06T13:38:46.981Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/da/0a422b57bf8504102bf3c4ccea9c41bab5a5cee6a54650acf8faf67f5a24/pydantic_core-2.46.4-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01", size = 2117231, upload-time = "2026-05-06T13:39:23.146Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2a/2ac13c3af305843e23c5078c53d135656b3f05a2fd78cb7bbbb12e97b473/pydantic_core-2.46.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d", size = 2168388, upload-time = "2026-05-06T13:40:08.06Z" },
+    { url = "https://files.pythonhosted.org/packages/72/04/2beacf7e1607e93eefe4aed1b4709f079b905fb77530179d4f7c71745f22/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4", size = 2184769, upload-time = "2026-05-06T13:38:13.901Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/29/d2b9fd9f539133548eaf622c06a4ce176cb46ac59f32d0359c4abc0de047/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f", size = 2319312, upload-time = "2026-05-06T13:39:08.24Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/af/0f7a5b85fec6075bea96e3ef9187de38fccced0de92c1e7feda8d5cc7bb9/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39", size = 2361817, upload-time = "2026-05-06T13:38:43.2Z" },
+    { url = "https://files.pythonhosted.org/packages/25/a4/73363fec545fd3ec025490bdda2743c56d0dd5b6266b1a53bbe9e4265375/pydantic_core-2.46.4-cp310-cp310-win32.whl", hash = "sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d", size = 1987085, upload-time = "2026-05-06T13:39:25.497Z" },
+    { url = "https://files.pythonhosted.org/packages/01/aa/62f082da2c91fac1c234bc9ee0066257ce83f0604abd72e4c9d5991f2d84/pydantic_core-2.46.4-cp310-cp310-win_amd64.whl", hash = "sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf", size = 2074311, upload-time = "2026-05-06T13:39:59.922Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/fa/6d7708d2cfc1a832acb6aeb0cd16e801902df8a0f583bb3b4b527fde022e/pydantic_core-2.46.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594", size = 2111872, upload-time = "2026-05-06T13:40:27.596Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6f/aa064a3e74b5745afbdf250594f38e7ead05e2d651bcb35994b9417a0d4d/pydantic_core-2.46.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c", size = 1948255, upload-time = "2026-05-06T13:39:12.574Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3a/41114a9f7569b84b4d84e7a018c57c56347dac30c0d4a872946ec4e36c46/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826", size = 1972827, upload-time = "2026-05-06T13:38:19.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/25/1ab42e8048fe551934d9884e8d64daa7e990ad386f310a15981aeb6a5b08/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04", size = 2041051, upload-time = "2026-05-06T13:38:10.447Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c2/1a934597ddf08da410385b3b7aae91956a5a76c635effef456074fad7e88/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e", size = 2221314, upload-time = "2026-05-06T13:40:13.089Z" },
+    { url = "https://files.pythonhosted.org/packages/02/6d/9e8ad178c9c4df27ad3c8f25d1fe2a7ab0d2ba0559fad4aee5d3d1f16771/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3", size = 2285146, upload-time = "2026-05-06T13:38:59.224Z" },
+    { url = "https://files.pythonhosted.org/packages/80/50/540cd3aeefc041beb111125c4bff779831a2111fc6b15a9138cda277d32c/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4", size = 2089685, upload-time = "2026-05-06T13:38:17.762Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/a4/b440ad35f05f6a38f89fa0f149accb3f0e02be94ca5e15f3c449a61b4bc9/pydantic_core-2.46.4-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398", size = 2115420, upload-time = "2026-05-06T13:37:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/99/61/de4f55db8dfd57bfdfa9a12ec90fe1b57c4f41062f7ca86f08586b3e0ac0/pydantic_core-2.46.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3", size = 2165122, upload-time = "2026-05-06T13:37:01.167Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/52/7c529d7bdb2d1068bd52f51fe32572c8301f9a4febf1948f10639f1436f5/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848", size = 2182573, upload-time = "2026-05-06T13:38:45.04Z" },
+    { url = "https://files.pythonhosted.org/packages/37/b3/7c40325848ba78247f2812dcf9c7274e38cd801820ca6dd9fe63bcfb0eb4/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3", size = 2317139, upload-time = "2026-05-06T13:37:15.539Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/37/f913f81a657c865b75da6c0dbed79876073c2a43b5bd9edbe8da785e4d49/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109", size = 2360433, upload-time = "2026-05-06T13:37:30.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/67/6acaa1be2567f9256b056d8477158cac7240813956ce86e49deae8e173b4/pydantic_core-2.46.4-cp311-cp311-win32.whl", hash = "sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda", size = 1985513, upload-time = "2026-05-06T13:38:15.669Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/e6/c505f83dfeda9a2e5c995cfd872949e4d05e12f7feb3dca72f633daefa94/pydantic_core-2.46.4-cp311-cp311-win_amd64.whl", hash = "sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33", size = 2071114, upload-time = "2026-05-06T13:40:35.416Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/da/7a263a96d965d9d0df5e8de8a475f33495451117035b09acb110288c381f/pydantic_core-2.46.4-cp311-cp311-win_arm64.whl", hash = "sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d", size = 2044298, upload-time = "2026-05-06T13:38:29.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+    { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" },
+    { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" },
+    { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" },
+    { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" },
+    { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" },
+    { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" },
+    { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" },
+    { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" },
+    { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" },
+    { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" },
+    { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" },
+    { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" },
+    { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/a4/73995fd4ebbb46ba0ee51e6fa049b8f02c40daebb762208feda8a6b7894d/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c", size = 2111589, upload-time = "2026-05-06T13:37:10.817Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7f/f37d3a5e8bfcc2e403f5c57a730f2d815693fb42119e8ea48b3789335af1/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b", size = 1944552, upload-time = "2026-05-06T13:36:56.717Z" },
+    { url = "https://files.pythonhosted.org/packages/15/3c/d7eb777b3ff43e8433a4efb39a17aa8fd98a4ee8561a24a67ef5db07b2d6/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b", size = 1982984, upload-time = "2026-05-06T13:39:06.207Z" },
+    { url = "https://files.pythonhosted.org/packages/63/87/70b9f40170a81afd55ca26c9b2acb25c20d64bcfbf888fafecb3ba077d4c/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea", size = 2138417, upload-time = "2026-05-06T13:39:45.476Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+    { url = "https://files.pythonhosted.org/packages/11/cb/428de0385b6c8d44b716feba566abfacfbd23ee3c4439faa789a1456242f/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0", size = 2112782, upload-time = "2026-05-06T13:37:04.016Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b5/6a17bdadd0fc1f170adfd05a20d37c832f52b117b4d9131da1f41bb097ce/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7", size = 1952146, upload-time = "2026-05-06T13:39:43.092Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/dc/03734d80e362cd43ef65428e9de77c730ce7f2f11c60d2b1e1b39f0fbf99/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2", size = 2134492, upload-time = "2026-05-06T13:36:58.124Z" },
+    { url = "https://files.pythonhosted.org/packages/de/df/5e5ffc085ed07cc22d298134d3d911c63e91f6a0eb91fe646750a3209910/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9", size = 2156604, upload-time = "2026-05-06T13:37:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/81/44/6e112a4253e56f5705467cbab7ab5e91ee7398ba3d56d358635958893d3e/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf", size = 2183828, upload-time = "2026-05-06T13:37:43.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/5565071e937d8e752842ac241463944c9eb14c87e2d269f2658a5bd05e98/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30", size = 2310000, upload-time = "2026-05-06T13:37:56.694Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c3/66883a5cec183e7fba4d024b4cbbe61851a63750ef606b0afecc46d1f2bf/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc", size = 2361286, upload-time = "2026-05-06T13:40:05.667Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/ea/5194e52748b0da83d71e082d75496eaec6e58f419f5e184786ded517e6a9/pyjwt-2.15.1.tar.gz", hash = "sha256:4f259e80cdfb6b3fc18a7de51fd1ef9ec79652f25019bae68975ca2468a34df8", size = 121252, upload-time = "2026-09-28T18:40:42.598Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/ca/44de4e75f8aadc457f0634be3b542815078ded46dca30efb960edeecad6e/pyjwt-2.15.1-py3-none-any.whl", hash = "sha256:42d59d631f7768a1028a64c7ff581a9bf7519804daf91fc5b6c56e30eec5e193", size = 33860, upload-time = "2026-09-28T18:40:41.429Z" },
+]
+
+[[package]]
+name = "pymysql"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/ae/1fe3fcd9f959efa0ebe200b8de88b5a5ce3e767e38c7ac32fb179f16a388/pymysql-1.1.2.tar.gz", hash = "sha256:4961d3e165614ae65014e361811a724e2044ad3ea3739de9903ae7c21f539f03", size = 48258, upload-time = "2025-08-24T12:55:55.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/4c/ad33b92b9864cbde84f259d5df035a6447f91891f5be77788e2a3892bce3/pymysql-1.1.2-py3-none-any.whl", hash = "sha256:e6b1d89711dd51f8f74b1631fe08f039e7d76cf67a42a323d3178f0f25762ed9", size = 45300, upload-time = "2025-08-24T12:55:53.394Z" },
 ]
 
 [[package]]
 name = "pytest"
-version = "8.3.5"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "iniconfig" },
     { name = "packaging" },
     { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
 name = "pytest-asyncio"
-version = "0.26.0"
+version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" },
     { name = "pytest" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8e/c4/453c52c659521066969523e87d85d54139bbd17b78f09532fb8eb8cdb58e/pytest_asyncio-0.26.0.tar.gz", hash = "sha256:c4df2a697648241ff39e7f0e4a73050b03f123f760673956cf0d72a4990e312f", size = 54156 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/7f/338843f449ace853647ace35870874f69a764d251872ed1b4de9f234822c/pytest_asyncio-0.26.0-py3-none-any.whl", hash = "sha256:7b51ed894f4fbea1340262bdae5135797ebbe21d8638978e35d31c6d19f72fb0", size = 19694 },
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
 ]
 
 [[package]]
 name = "pytest-cov"
-version = "6.1.1"
+version = "7.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "coverage" },
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/25/69/5f1e57f6c5a39f81411b550027bf72842c4567ff5fd572bed1edc9e4b5d9/pytest_cov-6.1.1.tar.gz", hash = "sha256:46935f7aaefba760e716c2ebfbe1c216240b9592966e7da99ea8292d4d3e2a0a", size = 66857 }
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/28/d0/def53b4a790cfb21483016430ed828f64830dd981ebe1089971cd10cab25/pytest_cov-6.1.1-py3-none-any.whl", hash = "sha256:bddf29ed2d0ab6f4df17b4c55b0a657287db8684af9c42ea546b21b1041b3dde", size = 23841 },
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
 ]
 
 [[package]]
 name = "pytest-mock"
-version = "3.14.0"
+version = "3.15.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 }
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 },
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
 ]
 
 [[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
+name = "pytest-timeout"
+version = "2.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "six" },
+    { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+    { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
 ]
 
 [[package]]
-name = "python-dotenv"
-version = "1.1.0"
+name = "pytest-xdist"
+version = "3.8.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/88/2c/7bb1416c5620485aa793f2de31d3df393d3686aa8a8506d11e10e13c5baf/python_dotenv-1.1.0.tar.gz", hash = "sha256:41f90bc6f5f177fb41f53e87666db362025010eb28f60a01c9143bfa33a2b2d5", size = 39920 }
+dependencies = [
+    { name = "execnet" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/18/98a99ad95133c6a6e2005fe89faedf294a748bd5dc803008059409ac9b1e/python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d", size = 20256 },
+    { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" },
 ]
 
 [[package]]
-name = "python-multipart"
-version = "0.0.20"
+name = "python-discovery"
+version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158 }
+dependencies = [
+    { name = "filelock" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/57/250bd238b966cece44328235eb85290045d059265fdaf7527a3a958123db/python_discovery-1.6.1.tar.gz", hash = "sha256:cf87d3627dfb4412437fdd5b13eae402607722998d21567993aedbc59b23c15e", size = 84338, upload-time = "2026-09-18T01:31:53.971Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 },
+    { url = "https://files.pythonhosted.org/packages/16/7d/e9ffbadfbf89c93848412d04594135c4ae8c1d37d9e053b9c3ed718fabc4/python_discovery-1.6.1-py3-none-any.whl", hash = "sha256:d43fcdef879fe795352bd13ccf8d185ba5a9f86f36cfcd00529f596e737442b3", size = 38664, upload-time = "2026-09-18T01:31:52.448Z" },
 ]
 
 [[package]]
 name = "pyyaml"
-version = "6.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 },
-    { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 },
-    { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 },
-    { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 },
-    { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 },
-    { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 },
-    { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 },
-    { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 },
-    { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 },
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
 [[package]]
 name = "requests"
-version = "2.32.3"
+version = "2.33.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -1594,351 +1832,503 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
+sdist = { url = "https://files.pythonhosted.org/packages/34/64/8860370b167a9721e8956ae116825caff829224fbca0ca6e7bf8ddef8430/requests-2.33.0.tar.gz", hash = "sha256:c7ebc5e8b0f21837386ad0e1c8fe8b829fa5f544d8df3b2253bff14ef29d7652", size = 134232, upload-time = "2026-03-25T15:10:41.586Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+    { url = "https://files.pythonhosted.org/packages/56/5d/c814546c2333ceea4ba42262d8c4d55763003e767fa169adc693bd524478/requests-2.33.0-py3-none-any.whl", hash = "sha256:3324635456fa185245e24865e810cecec7b4caf933d7eb133dcde67d48cee69b", size = 65017, upload-time = "2026-03-25T15:10:40.382Z" },
 ]
 
 [[package]]
-name = "requests-toolbelt"
-version = "1.0.0"
+name = "respx"
+version = "0.23.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "requests" },
+    { name = "httpx" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/98/4e55c9c486404ec12373708d015ebce157966965a5ebe7f28ff2c784d41b/respx-0.23.1.tar.gz", hash = "sha256:242dcc6ce6b5b9bf621f5870c82a63997e8e82bc7c947f9ffe272b8f3dd5a780", size = 29243, upload-time = "2026-04-08T14:37:16.008Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481 },
+    { url = "https://files.pythonhosted.org/packages/1d/4a/221da6ca167db45693d8d26c7dc79ccfc978a440251bf6721c9aaf251ac0/respx-0.23.1-py2.py3-none-any.whl", hash = "sha256:b18004b029935384bccfa6d7d9d74b4ec9af73a081cc28600fffc0447f4b8c1a", size = 25557, upload-time = "2026-04-08T14:37:14.613Z" },
 ]
 
 [[package]]
-name = "rsa"
-version = "4.9.1"
+name = "rfc8785"
+version = "0.1.4"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034 }
+sdist = { url = "https://files.pythonhosted.org/packages/ef/2f/fa1d2e740c490191b572d33dbca5daa180cb423c24396b856f5886371d8b/rfc8785-0.1.4.tar.gz", hash = "sha256:e545841329fe0eee4f6a3b44e7034343100c12b4ec566dc06ca9735681deb4da", size = 14321, upload-time = "2024-09-27T16:33:31.206Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696 },
+    { url = "https://files.pythonhosted.org/packages/4d/78/119878110660b2ad709888c8a1614fce7e2fab39080ab960656dc8605bf6/rfc8785-0.1.4-py3-none-any.whl", hash = "sha256:520d690b448ecf0703691c76e1a34a24ddcd4fc5bc41d589cb7c58ec651bcd48", size = 9240, upload-time = "2024-09-27T16:33:29.683Z" },
 ]
 
 [[package]]
 name = "ruff"
-version = "0.11.9"
+version = "0.15.16"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/e7/e55dda1c92cdcf34b677ebef17486669800de01e887b7831a1b8fdf5cb08/ruff-0.11.9.tar.gz", hash = "sha256:ebd58d4f67a00afb3a30bf7d383e52d0e036e6195143c6db7019604a05335517", size = 4132134 }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/5f7ec371001337d8fa61701c186ff8b613ecac1651848c5950f4c4d5f2e9/ruff-0.15.16.tar.gz", hash = "sha256:d05e78d38c78caf020b03789e25106c93017db5a0cb6e2819885018c61343b78", size = 4714267, upload-time = "2026-06-04T16:33:09.974Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/71/75dfb7194fe6502708e547941d41162574d1f579c4676a8eb645bf1a6842/ruff-0.11.9-py3-none-linux_armv6l.whl", hash = "sha256:a31a1d143a5e6f499d1fb480f8e1e780b4dfdd580f86e05e87b835d22c5c6f8c", size = 10335453 },
-    { url = "https://files.pythonhosted.org/packages/74/fc/ad80c869b1732f53c4232bbf341f33c5075b2c0fb3e488983eb55964076a/ruff-0.11.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:66bc18ca783b97186a1f3100e91e492615767ae0a3be584e1266aa9051990722", size = 11072566 },
-    { url = "https://files.pythonhosted.org/packages/87/0d/0ccececef8a0671dae155cbf7a1f90ea2dd1dba61405da60228bbe731d35/ruff-0.11.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:bd576cd06962825de8aece49f28707662ada6a1ff2db848d1348e12c580acbf1", size = 10435020 },
-    { url = "https://files.pythonhosted.org/packages/52/01/e249e1da6ad722278094e183cbf22379a9bbe5f21a3e46cef24ccab76e22/ruff-0.11.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b1d18b4be8182cc6fddf859ce432cc9631556e9f371ada52f3eaefc10d878de", size = 10593935 },
-    { url = "https://files.pythonhosted.org/packages/ed/9a/40cf91f61e3003fe7bd43f1761882740e954506c5a0f9097b1cff861f04c/ruff-0.11.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0f3f46f759ac623e94824b1e5a687a0df5cd7f5b00718ff9c24f0a894a683be7", size = 10172971 },
-    { url = "https://files.pythonhosted.org/packages/61/12/d395203de1e8717d7a2071b5a340422726d4736f44daf2290aad1085075f/ruff-0.11.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f34847eea11932d97b521450cf3e1d17863cfa5a94f21a056b93fb86f3f3dba2", size = 11748631 },
-    { url = "https://files.pythonhosted.org/packages/66/d6/ef4d5eba77677eab511644c37c55a3bb8dcac1cdeb331123fe342c9a16c9/ruff-0.11.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f33b15e00435773df97cddcd263578aa83af996b913721d86f47f4e0ee0ff271", size = 12409236 },
-    { url = "https://files.pythonhosted.org/packages/c5/8f/5a2c5fc6124dd925a5faf90e1089ee9036462118b619068e5b65f8ea03df/ruff-0.11.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7b27613a683b086f2aca8996f63cb3dd7bc49e6eccf590563221f7b43ded3f65", size = 11881436 },
-    { url = "https://files.pythonhosted.org/packages/39/d1/9683f469ae0b99b95ef99a56cfe8c8373c14eba26bd5c622150959ce9f64/ruff-0.11.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e0d88756e63e8302e630cee3ce2ffb77859797cc84a830a24473939e6da3ca6", size = 13982759 },
-    { url = "https://files.pythonhosted.org/packages/4e/0b/c53a664f06e0faab596397867c6320c3816df479e888fe3af63bc3f89699/ruff-0.11.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:537c82c9829d7811e3aa680205f94c81a2958a122ac391c0eb60336ace741a70", size = 11541985 },
-    { url = "https://files.pythonhosted.org/packages/23/a0/156c4d7e685f6526a636a60986ee4a3c09c8c4e2a49b9a08c9913f46c139/ruff-0.11.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:440ac6a7029f3dee7d46ab7de6f54b19e34c2b090bb4f2480d0a2d635228f381", size = 10465775 },
-    { url = "https://files.pythonhosted.org/packages/43/d5/88b9a6534d9d4952c355e38eabc343df812f168a2c811dbce7d681aeb404/ruff-0.11.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:71c539bac63d0788a30227ed4d43b81353c89437d355fdc52e0cda4ce5651787", size = 10170957 },
-    { url = "https://files.pythonhosted.org/packages/f0/b8/2bd533bdaf469dc84b45815ab806784d561fab104d993a54e1852596d581/ruff-0.11.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c67117bc82457e4501473c5f5217d49d9222a360794bfb63968e09e70f340abd", size = 11143307 },
-    { url = "https://files.pythonhosted.org/packages/2f/d9/43cfba291788459b9bfd4e09a0479aa94d05ab5021d381a502d61a807ec1/ruff-0.11.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e4b78454f97aa454586e8a5557facb40d683e74246c97372af3c2d76901d697b", size = 11603026 },
-    { url = "https://files.pythonhosted.org/packages/22/e6/7ed70048e89b01d728ccc950557a17ecf8df4127b08a56944b9d0bae61bc/ruff-0.11.9-py3-none-win32.whl", hash = "sha256:7fe1bc950e7d7b42caaee2a8a3bc27410547cc032c9558ee2e0f6d3b209e845a", size = 10548627 },
-    { url = "https://files.pythonhosted.org/packages/90/36/1da5d566271682ed10f436f732e5f75f926c17255c9c75cefb77d4bf8f10/ruff-0.11.9-py3-none-win_amd64.whl", hash = "sha256:52edaa4a6d70f8180343a5b7f030c7edd36ad180c9f4d224959c2d689962d964", size = 11634340 },
-    { url = "https://files.pythonhosted.org/packages/40/f7/70aad26e5877c8f7ee5b161c4c9fa0100e63fc4c944dc6d97b9c7e871417/ruff-0.11.9-py3-none-win_arm64.whl", hash = "sha256:bcf42689c22f2e240f496d0c183ef2c6f7b35e809f12c1db58f75d9aa8d630ca", size = 10741080 },
+    { url = "https://files.pythonhosted.org/packages/0c/42/53ef1c3953f157956db9bf7861e3bc50b9b887ce93300aa48cdba8336fe6/ruff-0.15.16-py3-none-linux_armv6l.whl", hash = "sha256:6ac3c0b3969cc6cf6b158c4e2f8f682acb58e7d700d8a44b65ecdc72d66ab0b2", size = 10709025, upload-time = "2026-06-04T16:32:51.935Z" },
+    { url = "https://files.pythonhosted.org/packages/93/9a/a79159346f19134a956607754e57d8d128f7a4c00f4ad2f7514d224c172c/ruff-0.15.16-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:197c207ed75ffba54a0dec23db4aa939a27a3053073e085e0042433cbdc58e4a", size = 11063550, upload-time = "2026-06-04T16:32:42.24Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/72/3ce2ac000a5299ec238e01f51397b3b653c93b077d9b1bfe8715bb895f20/ruff-0.15.16-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3a39fec45ab316cc23e7558f23fea4a70403ddb5648ea9a4a3854a16973d0071", size = 10421345, upload-time = "2026-06-04T16:32:37.251Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/c2/cc7fad3ec9169373f5b6a18f1917b91080feec40c3f9658334a1d28e2f03/ruff-0.15.16-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba93191d79003116b95128c9d306e045200fdbd0bccb782b110f3cd1d4abc5cf", size = 10757217, upload-time = "2026-06-04T16:32:54.722Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d2/3474009eaa0a65b31fa7152a2fad5e2f050c640ceb1e6b02ee6922e94c82/ruff-0.15.16-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6ee4b90520630120ef032aa5cc10db483852dff950e78b1d717e2993a61ac8d", size = 10507035, upload-time = "2026-06-04T16:33:05.343Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/81/b7ae6ccbd11f0c8dc3d5d67fc4be9b57ff57ca86ba56152021378e1277f2/ruff-0.15.16-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e4215bc938bc3c8215c1472c1aa437e310fee20cd427335fec9d7e609563628", size = 11255291, upload-time = "2026-06-04T16:32:49.49Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e1/46e526f1a7cc90857ce6ddf25fbb77eb6568651ac38d71b033af07076dd5/ruff-0.15.16-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7c8d26be963b090f10e29abc8b3e74a2a321f6fa34e02424e30b5af89350ecbb", size = 12124922, upload-time = "2026-06-04T16:33:07.821Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/da/5c791b088b596b24d0deb967fa28ae02ad751a140c0b9ea81c5ab915d6c0/ruff-0.15.16-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f198cf4123602a2280ed46c307bcbafe41758d6fee5b456b6b6058ca1514b3b4", size = 11332186, upload-time = "2026-06-04T16:33:02.971Z" },
+    { url = "https://files.pythonhosted.org/packages/72/11/5da87abe20047c8962361473923ebb2f62b595250126aadfad8c20649c1e/ruff-0.15.16-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb27515fa6240fb586ae82b901a59e67d24acff86f2190b433dc542fe0435aeb", size = 11373541, upload-time = "2026-06-04T16:32:47.007Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/2a/8554754c23a854ae3fd6b507e36ad61ddb121e298c6d5d617dec94ed0f14/ruff-0.15.16-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a267c46ba1593fc26b8eecbea050b39d40c0b6bb7781ee11c90a02cd10032951", size = 11353014, upload-time = "2026-06-04T16:32:34.795Z" },
+    { url = "https://files.pythonhosted.org/packages/62/25/62ea41529ec89f742ea3fed9cb1059c72877ec7cf9b9e99ac9cf3294d1d9/ruff-0.15.16-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:528c68f39a91498a8d50e91ff5985df3d105782bab49cc378e73ac26bff083e8", size = 10737467, upload-time = "2026-06-04T16:32:26.348Z" },
+    { url = "https://files.pythonhosted.org/packages/90/17/334d3ad9de4d40f9dd58fdd09e35ce64553bb501e2f19a839e2fb6be14fc/ruff-0.15.16-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7ed55c58950df60589a9a7a5d2f8fa5f54ebd287163be805adfe6ee95a9de123", size = 10521910, upload-time = "2026-06-04T16:32:32.54Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/bd/3ac7c6ae77a885c1004b3dda2446ea401768d24f851c14b4ad4b24f6639c/ruff-0.15.16-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d482feaf51512b50f9790ceb417a56a61dd1e9d9bf967662b9ed27c01b34f53a", size = 10979190, upload-time = "2026-06-04T16:32:57.492Z" },
+    { url = "https://files.pythonhosted.org/packages/33/d7/609546e6a413c3f216fbf2a50c928f97c80939154f6a0503114094a86191/ruff-0.15.16-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1e15bc8c94513dae2a40cc9ef07c94fdd4ecc9e29dabebeebe170f952322c9e3", size = 11477014, upload-time = "2026-06-04T16:32:44.687Z" },
+    { url = "https://files.pythonhosted.org/packages/74/0d/f2cd247ad32633a5c36e97141a2c21b11c6279f7957bc2ff360b1e08fddd/ruff-0.15.16-py3-none-win32.whl", hash = "sha256:580378f7bd4aa25f72e74aa54948a9622f142b1e509521dd10902e886681cc1e", size = 10735541, upload-time = "2026-06-04T16:32:30.145Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9e/02e845ef151b1dee585e55c4739f8e1734ae1d9f1221dff65761c162208b/ruff-0.15.16-py3-none-win_amd64.whl", hash = "sha256:408256017284eddf98fff77b29aa4fb30f586042d535b2d9befc6512f400aaec", size = 11843403, upload-time = "2026-06-04T16:32:39.76Z" },
+    { url = "https://files.pythonhosted.org/packages/15/19/016553f86f207450aebebc2b2b5088d086b901cc8186c02ac4284db3bd88/ruff-0.15.16-py3-none-win_arm64.whl", hash = "sha256:8cd61783afb39638a7133ef0d2dfb1e91277593962f81b5a8423eb0b888a6121", size = 11134555, upload-time = "2026-06-04T16:33:00.136Z" },
 ]
 
 [[package]]
-name = "shapely"
-version = "2.1.0"
+name = "setuptools"
+version = "84.1.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fb/fe/3b0d2f828ffaceadcdcb51b75b9c62d98e62dd95ce575278de35f24a1c20/shapely-2.1.0.tar.gz", hash = "sha256:2cbe90e86fa8fc3ca8af6ffb00a77b246b918c7cf28677b7c21489b678f6b02e", size = 313617 }
+sdist = { url = "https://files.pythonhosted.org/packages/73/eb/7e5f628ee2eb168fecbf8026de7856b2543d6d609cc85f086b9a91ac93d6/setuptools-84.1.0.tar.gz", hash = "sha256:23657205b63d4d31395ab917815247f694aafad28cd21316bf5fd45a51048ea0", size = 1171783, upload-time = "2026-10-19T20:11:43.489Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/77/4e368704b2193e74498473db4461d697cc6083c96f8039367e59009d78bd/shapely-2.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b64423295b563f43a043eb786e7a03200ebe68698e36d2b4b1c39f31dfb50dfb", size = 1830029 },
-    { url = "https://files.pythonhosted.org/packages/71/3c/d888597bda680e4de987316b05ca9db07416fa29523beff64f846503302f/shapely-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1b5578f45adc25b235b22d1ccb9a0348c8dc36f31983e57ea129a88f96f7b870", size = 1637999 },
-    { url = "https://files.pythonhosted.org/packages/03/8d/ee0e23b7ef88fba353c63a81f1f329c77f5703835db7b165e7c0b8b7f839/shapely-2.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1a7e83d383b27f02b684e50ab7f34e511c92e33b6ca164a6a9065705dd64bcb", size = 2929348 },
-    { url = "https://files.pythonhosted.org/packages/d1/a7/5c9cb413e4e2ce52c16be717e94abd40ce91b1f8974624d5d56154c5d40b/shapely-2.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:942031eb4d8f7b3b22f43ba42c09c7aa3d843aa10d5cc1619fe816e923b66e55", size = 3048973 },
-    { url = "https://files.pythonhosted.org/packages/84/23/45b90c0bd2157b238490ca56ef2eedf959d3514c7d05475f497a2c88b6d9/shapely-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d2843c456a2e5627ee6271800f07277c0d2652fb287bf66464571a057dbc00b3", size = 3873148 },
-    { url = "https://files.pythonhosted.org/packages/c0/bc/ed7d5d37f5395166042576f0c55a12d7e56102799464ba7ea3a72a38c769/shapely-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8c4b17469b7f39a5e6a7cfea79f38ae08a275427f41fe8b48c372e1449147908", size = 4052655 },
-    { url = "https://files.pythonhosted.org/packages/c0/8f/a1dafbb10d20d1c569f2db3fb1235488f624dafe8469e8ce65356800ba31/shapely-2.1.0-cp313-cp313-win32.whl", hash = "sha256:30e967abd08fce49513d4187c01b19f139084019f33bec0673e8dbeb557c45e4", size = 1526600 },
-    { url = "https://files.pythonhosted.org/packages/e3/f0/9f8cdf2258d7aed742459cea51c70d184de92f5d2d6f5f7f1ded90a18c31/shapely-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:1dc8d4364483a14aba4c844b7bd16a6fa3728887e2c33dfa1afa34a3cf4d08a5", size = 1707115 },
-    { url = "https://files.pythonhosted.org/packages/75/ed/32952df461753a65b3e5d24c8efb361d3a80aafaef0b70d419063f6f2c11/shapely-2.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:673e073fea099d1c82f666fb7ab0a00a77eff2999130a69357ce11941260d855", size = 1824847 },
-    { url = "https://files.pythonhosted.org/packages/ff/b9/2284de512af30b02f93ddcdd2e5c79834a3cf47fa3ca11b0f74396feb046/shapely-2.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6d1513f915a56de67659fe2047c1ad5ff0f8cbff3519d1e74fced69c9cb0e7da", size = 1631035 },
-    { url = "https://files.pythonhosted.org/packages/35/16/a59f252a7e736b73008f10d0950ffeeb0d5953be7c0bdffd39a02a6ba310/shapely-2.1.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d6a7043178890b9e028d80496ff4c79dc7629bff4d78a2f25323b661756bab8", size = 2968639 },
-    { url = "https://files.pythonhosted.org/packages/a5/0a/6a20eca7b0092cfa243117e8e145a58631a4833a0a519ec9b445172e83a0/shapely-2.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb638378dc3d76f7e85b67d7e2bb1366811912430ac9247ac00c127c2b444cdc", size = 3055713 },
-    { url = "https://files.pythonhosted.org/packages/fb/44/eeb0c7583b1453d1cf7a319a1d738e08f98a5dc993fa1ef3c372983e4cb5/shapely-2.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:737124e87d91d616acf9a911f74ac55e05db02a43a6a7245b3d663817b876055", size = 3890478 },
-    { url = "https://files.pythonhosted.org/packages/5d/6e/37ff3c6af1d408cacb0a7d7bfea7b8ab163a5486e35acb08997eae9d8756/shapely-2.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e6c229e7bb87aae5df82fa00b6718987a43ec168cc5affe095cca59d233f314", size = 4036148 },
-    { url = "https://files.pythonhosted.org/packages/c8/6a/8c0b7de3aeb5014a23f06c5e9d3c7852ebcf0d6b00fe660b93261e310e24/shapely-2.1.0-cp313-cp313t-win32.whl", hash = "sha256:a9580bda119b1f42f955aa8e52382d5c73f7957e0203bc0c0c60084846f3db94", size = 1535993 },
-    { url = "https://files.pythonhosted.org/packages/a8/91/ae80359a58409d52e4d62c7eacc7eb3ddee4b9135f1db884b6a43cf2e174/shapely-2.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e8ff4e5cfd799ba5b6f37b5d5527dbd85b4a47c65b6d459a03d0962d2a9d4d10", size = 1717777 },
+    { url = "https://files.pythonhosted.org/packages/18/02/b4bbb90f8f29e334898ff45c6d9b1fffaa6f378017052b3023a06262b5f7/setuptools-84.1.0-py3-none-any.whl", hash = "sha256:5231689c6ac8156cd155cfb98c3fd6fb252c3e7e9bd3d78b64d3c55f132624c9", size = 819380, upload-time = "2026-10-19T20:11:41.684Z" },
 ]
 
 [[package]]
-name = "six"
-version = "1.17.0"
+name = "sniffio"
+version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
 [[package]]
-name = "sniffio"
-version = "1.3.1"
+name = "sortedcontainers"
+version = "2.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
 ]
 
 [[package]]
 name = "sqlalchemy"
-version = "2.0.41"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "greenlet", marker = "(python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64')" },
-    { name = "typing-extensions" },
+version = "2.0.48"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/73/b4a9737255583b5fa858e0bb8e116eb94b88c910164ed2ed719147bde3de/sqlalchemy-2.0.48.tar.gz", hash = "sha256:5ca74f37f3369b45e1f6b7b06afb182af1fd5dde009e4ffd831830d98cbe5fe7", size = 9886075, upload-time = "2026-03-02T15:28:51.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/67/1235676e93dd3b742a4a8eddfae49eea46c85e3eed29f0da446a8dd57500/sqlalchemy-2.0.48-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7001dc9d5f6bb4deb756d5928eaefe1930f6f4179da3924cbd95ee0e9f4dce89", size = 2157384, upload-time = "2026-03-02T15:38:26.781Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/d7/fa728b856daa18c10e1390e76f26f64ac890c947008284387451d56ca3d0/sqlalchemy-2.0.48-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1a89ce07ad2d4b8cfc30bd5889ec40613e028ed80ef47da7d9dd2ce969ad30e0", size = 3236981, upload-time = "2026-03-02T15:58:53.53Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ad/6c4395649a212a6c603a72c5b9ab5dce3135a1546cfdffa3c427e71fd535/sqlalchemy-2.0.48-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10853a53a4a00417a00913d270dddda75815fcb80675874285f41051c094d7dd", size = 3235232, upload-time = "2026-03-02T15:52:25.654Z" },
+    { url = "https://files.pythonhosted.org/packages/01/f4/58f845e511ac0509765a6f85eb24924c1ef0d54fb50de9d15b28c3601458/sqlalchemy-2.0.48-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fac0fa4e4f55f118fd87177dacb1c6522fe39c28d498d259014020fec9164c29", size = 3188106, upload-time = "2026-03-02T15:58:55.193Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/f9/6dcc7bfa5f5794c3a095e78cd1de8269dfb5584dfd4c2c00a50d3c1ade44/sqlalchemy-2.0.48-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3713e21ea67bca727eecd4a24bf68bcd414c403faae4989442be60994301ded0", size = 3209522, upload-time = "2026-03-02T15:52:27.407Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/5a/b632875ab35874d42657f079529f0745410604645c269a8c21fb4272ff7a/sqlalchemy-2.0.48-cp310-cp310-win32.whl", hash = "sha256:d404dc897ce10e565d647795861762aa2d06ca3f4a728c5e9a835096c7059018", size = 2117695, upload-time = "2026-03-02T15:46:51.389Z" },
+    { url = "https://files.pythonhosted.org/packages/de/03/9752eb2a41afdd8568e41ac3c3128e32a0a73eada5ab80483083604a56d1/sqlalchemy-2.0.48-cp310-cp310-win_amd64.whl", hash = "sha256:841a94c66577661c1f088ac958cd767d7c9bf507698f45afffe7a4017049de76", size = 2140928, upload-time = "2026-03-02T15:46:52.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6d/b8b78b5b80f3c3ab3f7fa90faa195ec3401f6d884b60221260fd4d51864c/sqlalchemy-2.0.48-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b4c575df7368b3b13e0cebf01d4679f9a28ed2ae6c1cd0b1d5beffb6b2007dc", size = 2157184, upload-time = "2026-03-02T15:38:28.161Z" },
+    { url = "https://files.pythonhosted.org/packages/21/4b/4f3d4a43743ab58b95b9ddf5580a265b593d017693df9e08bd55780af5bb/sqlalchemy-2.0.48-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e83e3f959aaa1c9df95c22c528096d94848a1bc819f5d0ebf7ee3df0ca63db6c", size = 3313555, upload-time = "2026-03-02T15:58:57.21Z" },
+    { url = "https://files.pythonhosted.org/packages/21/dd/3b7c53f1dbbf736fd27041aee68f8ac52226b610f914085b1652c2323442/sqlalchemy-2.0.48-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f7b7243850edd0b8b97043f04748f31de50cf426e939def5c16bedb540698f7", size = 3313057, upload-time = "2026-03-02T15:52:29.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cc/3e600a90ae64047f33313d7d32e5ad025417f09d2ded487e8284b5e21a15/sqlalchemy-2.0.48-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:82745b03b4043e04600a6b665cb98697c4339b24e34d74b0a2ac0a2488b6f94d", size = 3265431, upload-time = "2026-03-02T15:58:59.096Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/19/780138dacfe3f5024f4cf96e4005e91edf6653d53d3673be4844578faf1d/sqlalchemy-2.0.48-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e5e088bf43f6ee6fec7dbf1ef7ff7774a616c236b5c0cb3e00662dd71a56b571", size = 3287646, upload-time = "2026-03-02T15:52:31.569Z" },
+    { url = "https://files.pythonhosted.org/packages/40/fd/f32ced124f01a23151f4777e4c705f3a470adc7bd241d9f36a7c941a33bf/sqlalchemy-2.0.48-cp311-cp311-win32.whl", hash = "sha256:9c7d0a77e36b5f4b01ca398482230ab792061d243d715299b44a0b55c89fe617", size = 2116956, upload-time = "2026-03-02T15:46:54.535Z" },
+    { url = "https://files.pythonhosted.org/packages/58/d5/dd767277f6feef12d05651538f280277e661698f617fa4d086cce6055416/sqlalchemy-2.0.48-cp311-cp311-win_amd64.whl", hash = "sha256:583849c743e0e3c9bb7446f5b5addeacedc168d657a69b418063dfdb2d90081c", size = 2141627, upload-time = "2026-03-02T15:46:55.849Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/91/a42ae716f8925e9659df2da21ba941f158686856107a61cc97a95e7647a3/sqlalchemy-2.0.48-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:348174f228b99f33ca1f773e85510e08927620caa59ffe7803b37170df30332b", size = 2155737, upload-time = "2026-03-02T15:49:13.207Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/52/f75f516a1f3888f027c1cfb5d22d4376f4b46236f2e8669dcb0cddc60275/sqlalchemy-2.0.48-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53667b5f668991e279d21f94ccfa6e45b4e3f4500e7591ae59a8012d0f010dcb", size = 3337020, upload-time = "2026-03-02T15:50:34.547Z" },
+    { url = "https://files.pythonhosted.org/packages/37/9a/0c28b6371e0cdcb14f8f1930778cb3123acfcbd2c95bb9cf6b4a2ba0cce3/sqlalchemy-2.0.48-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34634e196f620c7a61d18d5cf7dc841ca6daa7961aed75d532b7e58b309ac894", size = 3349983, upload-time = "2026-03-02T15:53:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/46/0aee8f3ff20b1dcbceb46ca2d87fcc3d48b407925a383ff668218509d132/sqlalchemy-2.0.48-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:546572a1793cc35857a2ffa1fe0e58571af1779bcc1ffa7c9fb0839885ed69a9", size = 3279690, upload-time = "2026-03-02T15:50:36.277Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8c/a957bc91293b49181350bfd55e6dfc6e30b7f7d83dc6792d72043274a390/sqlalchemy-2.0.48-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:07edba08061bc277bfdc772dd2a1a43978f5a45994dd3ede26391b405c15221e", size = 3314738, upload-time = "2026-03-02T15:53:27.519Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/44/1d257d9f9556661e7bdc83667cc414ba210acfc110c82938cb3611eea58f/sqlalchemy-2.0.48-cp312-cp312-win32.whl", hash = "sha256:908a3fa6908716f803b86896a09a2c4dde5f5ce2bb07aacc71ffebb57986ce99", size = 2115546, upload-time = "2026-03-02T15:54:31.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/af/c3c7e1f3a2b383155a16454df62ae8c62a30dd238e42e68c24cebebbfae6/sqlalchemy-2.0.48-cp312-cp312-win_amd64.whl", hash = "sha256:68549c403f79a8e25984376480959975212a670405e3913830614432b5daa07a", size = 2142484, upload-time = "2026-03-02T15:54:34.072Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c6/569dc8bf3cd375abc5907e82235923e986799f301cd79a903f784b996fca/sqlalchemy-2.0.48-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e3070c03701037aa418b55d36532ecb8f8446ed0135acb71c678dbdf12f5b6e4", size = 2152599, upload-time = "2026-03-02T15:49:14.41Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/f4e04a4bd5a24304f38cb0d4aa2ad4c0fb34999f8b884c656535e1b2b74c/sqlalchemy-2.0.48-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2645b7d8a738763b664a12a1542c89c940daa55196e8d73e55b169cc5c99f65f", size = 3278825, upload-time = "2026-03-02T15:50:38.269Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/88/cb59509e4668d8001818d7355d9995be90c321313078c912420603a7cb95/sqlalchemy-2.0.48-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b19151e76620a412c2ac1c6f977ab1b9fa7ad43140178345136456d5265b32ed", size = 3295200, upload-time = "2026-03-02T15:53:29.366Z" },
+    { url = "https://files.pythonhosted.org/packages/87/dc/1609a4442aefd750ea2f32629559394ec92e89ac1d621a7f462b70f736ff/sqlalchemy-2.0.48-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b193a7e29fd9fa56e502920dca47dffe60f97c863494946bd698c6058a55658", size = 3226876, upload-time = "2026-03-02T15:50:39.802Z" },
+    { url = "https://files.pythonhosted.org/packages/37/c3/6ae2ab5ea2fa989fbac4e674de01224b7a9d744becaf59bb967d62e99bed/sqlalchemy-2.0.48-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:36ac4ddc3d33e852da9cb00ffb08cea62ca05c39711dc67062ca2bb1fae35fd8", size = 3265045, upload-time = "2026-03-02T15:53:31.421Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/82/ea4665d1bb98c50c19666e672f21b81356bd6077c4574e3d2bbb84541f53/sqlalchemy-2.0.48-cp313-cp313-win32.whl", hash = "sha256:389b984139278f97757ea9b08993e7b9d1142912e046ab7d82b3fbaeb0209131", size = 2113700, upload-time = "2026-03-02T15:54:35.825Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/2b/b9040bec58c58225f073f5b0c1870defe1940835549dafec680cbd58c3c3/sqlalchemy-2.0.48-cp313-cp313-win_amd64.whl", hash = "sha256:d612c976cbc2d17edfcc4c006874b764e85e990c29ce9bd411f926bbfb02b9a2", size = 2139487, upload-time = "2026-03-02T15:54:37.079Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/7b17bd50244b78a49d22cc63c969d71dc4de54567dc152a9b46f6fae40ce/sqlalchemy-2.0.48-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69f5bc24904d3bc3640961cddd2523e361257ef68585d6e364166dfbe8c78fae", size = 3558851, upload-time = "2026-03-02T15:57:48.607Z" },
+    { url = "https://files.pythonhosted.org/packages/20/0d/213668e9aca61d370f7d2a6449ea4ec699747fac67d4bda1bb3d129025be/sqlalchemy-2.0.48-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd08b90d211c086181caed76931ecfa2bdfc83eea3cfccdb0f82abc6c4b876cb", size = 3525525, upload-time = "2026-03-02T16:04:38.058Z" },
+    { url = "https://files.pythonhosted.org/packages/85/d7/a84edf412979e7d59c69b89a5871f90a49228360594680e667cb2c46a828/sqlalchemy-2.0.48-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1ccd42229aaac2df431562117ac7e667d702e8e44afdb6cf0e50fa3f18160f0b", size = 3466611, upload-time = "2026-03-02T15:57:50.759Z" },
+    { url = "https://files.pythonhosted.org/packages/86/55/42404ce5770f6be26a2b0607e7866c31b9a4176c819e9a7a5e0a055770be/sqlalchemy-2.0.48-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f0dcbc588cd5b725162c076eb9119342f6579c7f7f55057bb7e3c6ff27e13121", size = 3475812, upload-time = "2026-03-02T16:04:40.092Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/ae/29b87775fadc43e627cf582fe3bda4d02e300f6b8f2747c764950d13784c/sqlalchemy-2.0.48-cp313-cp313t-win32.whl", hash = "sha256:9764014ef5e58aab76220c5664abb5d47d5bc858d9debf821e55cfdd0f128485", size = 2141335, upload-time = "2026-03-02T15:52:51.518Z" },
+    { url = "https://files.pythonhosted.org/packages/91/44/f39d063c90f2443e5b46ec4819abd3d8de653893aae92df42a5c4f5843de/sqlalchemy-2.0.48-cp313-cp313t-win_amd64.whl", hash = "sha256:e2f35b4cccd9ed286ad62e0a3c3ac21e06c02abc60e20aa51a3e305a30f5fa79", size = 2173095, upload-time = "2026-03-02T15:52:52.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b3/f437eaa1cf028bb3c927172c7272366393e73ccd104dcf5b6963f4ab5318/sqlalchemy-2.0.48-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e2d0d88686e3d35a76f3e15a34e8c12d73fc94c1dea1cd55782e695cc14086dd", size = 2154401, upload-time = "2026-03-02T15:49:17.24Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/1c/b3abdf0f402aa3f60f0df6ea53d92a162b458fca2321d8f1f00278506402/sqlalchemy-2.0.48-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49b7bddc1eebf011ea5ab722fdbe67a401caa34a350d278cc7733c0e88fecb1f", size = 3274528, upload-time = "2026-03-02T15:50:41.489Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/5e/327428a034407651a048f5e624361adf3f9fbac9d0fa98e981e9c6ff2f5e/sqlalchemy-2.0.48-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:426c5ca86415d9b8945c7073597e10de9644802e2ff502b8e1f11a7a2642856b", size = 3279523, upload-time = "2026-03-02T15:53:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ca/ece73c81a918add0965b76b868b7b5359e068380b90ef1656ee995940c02/sqlalchemy-2.0.48-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:288937433bd44e3990e7da2402fabc44a3c6c25d3704da066b85b89a85474ae0", size = 3224312, upload-time = "2026-03-02T15:50:42.996Z" },
+    { url = "https://files.pythonhosted.org/packages/88/11/fbaf1ae91fa4ee43f4fe79661cead6358644824419c26adb004941bdce7c/sqlalchemy-2.0.48-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8183dc57ae7d9edc1346e007e840a9f3d6aa7b7f165203a99e16f447150140d2", size = 3246304, upload-time = "2026-03-02T15:53:34.937Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5fb0deb13930b4f2f698c5541ae076c18981173e27dd00376dbaea7a9c82/sqlalchemy-2.0.48-cp314-cp314-win32.whl", hash = "sha256:1182437cb2d97988cfea04cf6cdc0b0bb9c74f4d56ec3d08b81e23d621a28cc6", size = 2116565, upload-time = "2026-03-02T15:54:38.321Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7e/e83615cb63f80047f18e61e31e8e32257d39458426c23006deeaf48f463b/sqlalchemy-2.0.48-cp314-cp314-win_amd64.whl", hash = "sha256:144921da96c08feb9e2b052c5c5c1d0d151a292c6135623c6b2c041f2a45f9e0", size = 2142205, upload-time = "2026-03-02T15:54:39.831Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e3/69d8711b3f2c5135e9cde5f063bc1605860f0b2c53086d40c04017eb1f77/sqlalchemy-2.0.48-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5aee45fd2c6c0f2b9cdddf48c48535e7471e42d6fb81adfde801da0bd5b93241", size = 3563519, upload-time = "2026-03-02T15:57:52.387Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4f/a7cce98facca73c149ea4578981594aaa5fd841e956834931de503359336/sqlalchemy-2.0.48-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7cddca31edf8b0653090cbb54562ca027c421c58ddde2c0685f49ff56a1690e0", size = 3528611, upload-time = "2026-03-02T16:04:42.097Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7d/5936c7a03a0b0cb0fa0cc425998821c6029756b0855a8f7ee70fba1de955/sqlalchemy-2.0.48-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7a936f1bb23d370b7c8cc079d5fce4c7d18da87a33c6744e51a93b0f9e97e9b3", size = 3472326, upload-time = "2026-03-02T15:57:54.423Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/33/cea7dfc31b52904efe3dcdc169eb4514078887dff1f5ae28a7f4c5d54b3c/sqlalchemy-2.0.48-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e004aa9248e8cb0a5f9b96d003ca7c1c0a5da8decd1066e7b53f59eb8ce7c62b", size = 3478453, upload-time = "2026-03-02T16:04:44.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/95/32107c4d13be077a9cae61e9ae49966a35dc4bf442a8852dd871db31f62e/sqlalchemy-2.0.48-cp314-cp314t-win32.whl", hash = "sha256:b8438ec5594980d405251451c5b7ea9aa58dda38eb7ac35fb7e4c696712ee24f", size = 2147209, upload-time = "2026-03-02T15:52:54.274Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d7/1e073da7a4bc645eb83c76067284a0374e643bc4be57f14cc6414656f92c/sqlalchemy-2.0.48-cp314-cp314t-win_amd64.whl", hash = "sha256:d854b3970067297f3a7fbd7a4683587134aa9b3877ee15aa29eea478dc68f933", size = 2182198, upload-time = "2026-03-02T15:52:55.606Z" },
+    { url = "https://files.pythonhosted.org/packages/46/2c/9664130905f03db57961b8980b05cab624afd114bf2be2576628a9f22da4/sqlalchemy-2.0.48-py3-none-any.whl", hash = "sha256:a66fe406437dd65cacd96a72689a3aaaecaebbcd62d81c5ac1c0fdbeac835096", size = 1940202, upload-time = "2026-03-02T15:52:43.285Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/63/66/45b165c595ec89aa7dcc2c1cd222ab269bc753f1fc7a1e68f8481bd957bf/sqlalchemy-2.0.41.tar.gz", hash = "sha256:edba70118c4be3c2b1f90754d308d0b79c6fe2c0fdc52d8ddf603916f83f4db9", size = 9689424 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/ad/2e1c6d4f235a97eeef52d0200d8ddda16f6c4dd70ae5ad88c46963440480/sqlalchemy-2.0.41-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4eeb195cdedaf17aab6b247894ff2734dcead6c08f748e617bfe05bd5a218443", size = 2115491 },
-    { url = "https://files.pythonhosted.org/packages/cf/8d/be490e5db8400dacc89056f78a52d44b04fbf75e8439569d5b879623a53b/sqlalchemy-2.0.41-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d4ae769b9c1c7757e4ccce94b0641bc203bbdf43ba7a2413ab2523d8d047d8dc", size = 2102827 },
-    { url = "https://files.pythonhosted.org/packages/a0/72/c97ad430f0b0e78efaf2791342e13ffeafcbb3c06242f01a3bb8fe44f65d/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a62448526dd9ed3e3beedc93df9bb6b55a436ed1474db31a2af13b313a70a7e1", size = 3225224 },
-    { url = "https://files.pythonhosted.org/packages/5e/51/5ba9ea3246ea068630acf35a6ba0d181e99f1af1afd17e159eac7e8bc2b8/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc56c9788617b8964ad02e8fcfeed4001c1f8ba91a9e1f31483c0dffb207002a", size = 3230045 },
-    { url = "https://files.pythonhosted.org/packages/78/2f/8c14443b2acea700c62f9b4a8bad9e49fc1b65cfb260edead71fd38e9f19/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c153265408d18de4cc5ded1941dcd8315894572cddd3c58df5d5b5705b3fa28d", size = 3159357 },
-    { url = "https://files.pythonhosted.org/packages/fc/b2/43eacbf6ccc5276d76cea18cb7c3d73e294d6fb21f9ff8b4eef9b42bbfd5/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f67766965996e63bb46cfbf2ce5355fc32d9dd3b8ad7e536a920ff9ee422e23", size = 3197511 },
-    { url = "https://files.pythonhosted.org/packages/fa/2e/677c17c5d6a004c3c45334ab1dbe7b7deb834430b282b8a0f75ae220c8eb/sqlalchemy-2.0.41-cp313-cp313-win32.whl", hash = "sha256:bfc9064f6658a3d1cadeaa0ba07570b83ce6801a1314985bf98ec9b95d74e15f", size = 2082420 },
-    { url = "https://files.pythonhosted.org/packages/e9/61/e8c1b9b6307c57157d328dd8b8348ddc4c47ffdf1279365a13b2b98b8049/sqlalchemy-2.0.41-cp313-cp313-win_amd64.whl", hash = "sha256:82ca366a844eb551daff9d2e6e7a9e5e76d2612c8564f58db6c19a726869c1df", size = 2108329 },
-    { url = "https://files.pythonhosted.org/packages/1c/fc/9ba22f01b5cdacc8f5ed0d22304718d2c758fce3fd49a5372b886a86f37c/sqlalchemy-2.0.41-py3-none-any.whl", hash = "sha256:57df5dc6fdb5ed1a88a1ed2195fd31927e705cad62dedd86b46972752a80f576", size = 1911224 },
+
+[package.optional-dependencies]
+aiomysql = [
+    { name = "aiomysql" },
+    { name = "greenlet" },
+]
+aiosqlite = [
+    { name = "aiosqlite" },
+    { name = "greenlet" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+asyncio = [
+    { name = "greenlet" },
+]
+postgresql-asyncpg = [
+    { name = "asyncpg" },
+    { name = "greenlet" },
 ]
 
 [[package]]
 name = "sse-starlette"
-version = "2.3.5"
+version = "3.4.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "starlette" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/10/5f/28f45b1ff14bee871bacafd0a97213f7ec70e389939a80c60c0fb72a9fc9/sse_starlette-2.3.5.tar.gz", hash = "sha256:228357b6e42dcc73a427990e2b4a03c023e2495ecee82e14f07ba15077e334b2", size = 17511 }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/2b/58abc2d1fd397e7dde08e947e05c884d8ef2f78d5e2588c17a12d42d6994/sse_starlette-3.4.4.tar.gz", hash = "sha256:07e0fa0460138baf25cdd5fb28683472c3995dc1642225191b3832d62526bcb0", size = 31819, upload-time = "2026-05-12T17:37:17.019Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/48/3e49cf0f64961656402c0023edbc51844fe17afe53ab50e958a6dbbbd499/sse_starlette-2.3.5-py3-none-any.whl", hash = "sha256:251708539a335570f10eaaa21d1848a10c42ee6dc3a9cf37ef42266cdb1c52a8", size = 10233 },
+    { url = "https://files.pythonhosted.org/packages/dc/67/805710444ea8cc75fbf70b920ed431a560c4bf9c57f7d5a3117213189399/sse_starlette-3.4.4-py3-none-any.whl", hash = "sha256:3f4dd50d8aed2771a091f3a83000323fc3844541c16b4fe585ae2420cc6df973", size = 16514, upload-time = "2026-05-12T17:37:15.601Z" },
 ]
 
 [[package]]
 name = "starlette"
-version = "0.46.2"
+version = "1.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/20/08dfcd9c983f6a6f4a1000d934b9e6d626cff8d2eeb77a89a68eef20a2b7/starlette-0.46.2.tar.gz", hash = "sha256:7f7361f34eed179294600af672f565727419830b54b7b084efe44bb82d2fccd5", size = 2580846 }
+sdist = { url = "https://files.pythonhosted.org/packages/25/44/ec35f1b6e83094b997da438a02c8c9b0ade2b1e84cfc48bd4656780760a6/starlette-1.2.1.tar.gz", hash = "sha256:9b9b5ebb992e67d6093741e63c2f59e4f6fff986f81163c087867bd7b924b3f6", size = 2701854, upload-time = "2026-05-31T01:07:51.847Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0c/9d30a4ebeb6db2b25a841afbb80f6ef9a854fc3b41be131d249a977b4959/starlette-0.46.2-py3-none-any.whl", hash = "sha256:595633ce89f8ffa71a015caed34a5b2dc1c0cdb3f0f1fbd1e69339cf2abeec35", size = 72037 },
+    { url = "https://files.pythonhosted.org/packages/1c/54/196d0c1db10af76baa4f64894448505d60d3cdf70ef92cbb35f46a4e4c71/starlette-1.2.1-py3-none-any.whl", hash = "sha256:4de0082d08c8f6764a85a54cf1120d6939507a19905c7768acad2a9f875d2b89", size = 73350, upload-time = "2026-05-31T01:07:50.09Z" },
 ]
 
 [[package]]
-name = "tenacity"
-version = "9.1.2"
+name = "tomli"
+version = "2.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036 }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
+]
+
+[[package]]
+name = "tomlkit"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/af/14b24e41977adb296d6bd1fb59402cf7d60ce364f90c890bd2ec65c43b5a/tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064", size = 187167, upload-time = "2026-01-13T01:14:53.304Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/11/87d6d29fb5d237229d67973a6c9e06e048f01cf4994dee194ab0ea841814/tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680", size = 39310, upload-time = "2026-01-13T01:14:51.965Z" },
+]
+
+[[package]]
+name = "trio"
+version = "0.33.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "outcome" },
+    { name = "sniffio" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/b6/c744031c6f89b18b3f5f4f7338603ab381d740a7f45938c4607b2302481f/trio-0.33.0.tar.gz", hash = "sha256:a29b92b73f09d4b48ed249acd91073281a7f1063f09caba5dc70465b5c7aa970", size = 605109, upload-time = "2026-02-14T18:40:55.386Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248 },
+    { url = "https://files.pythonhosted.org/packages/1c/93/dab25dc87ac48da0fe0f6419e07d0bfd98799bed4e05e7b9e0f85a1a4b4b/trio-0.33.0-py3-none-any.whl", hash = "sha256:3bd5d87f781d9b0192d592aef28691f8951d6c2e41b7e1da4c25cde6c180ae9b", size = 510294, upload-time = "2026-02-14T18:40:53.313Z" },
 ]
 
 [[package]]
-name = "typeguard"
-version = "4.4.2"
+name = "trove-classifiers"
+version = "2026.1.14.14"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
+sdist = { url = "https://files.pythonhosted.org/packages/d8/43/7935f8ea93fcb6680bc10a6fdbf534075c198eeead59150dd5ed68449642/trove_classifiers-2026.1.14.14.tar.gz", hash = "sha256:00492545a1402b09d4858605ba190ea33243d361e2b01c9c296ce06b5c3325f3", size = 16997, upload-time = "2026-01-14T14:54:50.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/4a/2e5583e544bc437d5e8e54b47db87430df9031b29b48d17f26d129fa60c0/trove_classifiers-2026.1.14.14-py3-none-any.whl", hash = "sha256:1f9553927f18d0513d8e5ff80ab8980b8202ce37ecae0e3274ed2ef11880e74d", size = 14197, upload-time = "2026-01-14T14:54:49.067Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/60/8cd6a3d78d00ceeb2193c02b7ed08f063d5341ccdfb24df88e61f383048e/typeguard-4.4.2.tar.gz", hash = "sha256:a6f1065813e32ef365bc3b3f503af8a96f9dd4e0033a02c28c4a4983de8c6c49", size = 75746 }
+
+[[package]]
+name = "ty"
+version = "0.0.44"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/f4/fbb120226e4f239652525a664bad976a23fea58c646d1323f2296fee8a61/ty-0.0.44.tar.gz", hash = "sha256:5886229830ab77022842a1c55d2ef57405621a91fc465969fa6d538661898173", size = 5803665, upload-time = "2026-06-05T03:33:48.612Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cf/4b/9a77dc721aa0b7f74440a42e4ef6f9a4fae7324e17f64f88b96f4c25cc05/typeguard-4.4.2-py3-none-any.whl", hash = "sha256:77a78f11f09777aeae7fa08585f33b5f4ef0e7335af40005b0c422ed398ff48c", size = 35801 },
+    { url = "https://files.pythonhosted.org/packages/e8/c6/b5b8c4762efb4d85401652658786506867553ecfc2beac3bcf361a15937f/ty-0.0.44-py3-none-linux_armv6l.whl", hash = "sha256:272d31e7ad49b1dc5e8465a9fe700354e14c755b40d9c75f08f031d786903df3", size = 11607267, upload-time = "2026-06-05T03:33:27.154Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5c/f4b405570737f44ab0fc4214117fe43353f8f0825a1823d9e99e9c8e57be/ty-0.0.44-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b92c4ddd7a3daf2049715edec9dc70cf6fd31a5a318ee647258f90dd75495eed", size = 11382826, upload-time = "2026-06-05T03:33:54.374Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/aa/fb9835aa492b148d7754cb4c3db07f31a7e2e09f0d8e0e8e297f01125dd2/ty-0.0.44-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4d42cfd84a690f6654b2a4f0515027c21b692cf2512d32e6433f754893a95609", size = 10809741, upload-time = "2026-06-05T03:33:33.22Z" },
+    { url = "https://files.pythonhosted.org/packages/47/f5/0b20ba6b66837a5a37bab7f74ac0732c66e766b5f0b2d55b30816b15f348/ty-0.0.44-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc47ae87e4cb7db2a9166bb23b78a905c3626e523296ec5bccf36b5e89bda6b", size = 11318153, upload-time = "2026-06-05T03:34:09.403Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/bb/b82ea730774a4f950f06d355fbc120d51eac7da23b57fc79ef6ff7c79cbb/ty-0.0.44-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46d867e80f16f421ac72c9a85240dbf050d62d9b3fbd10a8b5b082fb21679e0b", size = 11403108, upload-time = "2026-06-05T03:33:57.745Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/41/e2c83856165291049c702eda4e2ef3d3ebd875e8a0a77b8cc4ef3156aa1c/ty-0.0.44-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:411f5de0f96a4e4e5cccc3e0d55954c41f6a99ee6ca1fe5a7226cbc68406e053", size = 11944815, upload-time = "2026-06-05T03:34:15.793Z" },
+    { url = "https://files.pythonhosted.org/packages/66/95/1fa6a101eb9d5bec042b87e5ca9c8fc349b75961beca6306f95af5cd5539/ty-0.0.44-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b15f01ecb4e2b46c05a1769293f9d32c3d4a1e4e7dfccf37c604d705dc3e3f4", size = 12476121, upload-time = "2026-06-05T03:33:51.529Z" },
+    { url = "https://files.pythonhosted.org/packages/72/6a/da4b45b1229d39207c6140681c2aaf4f5691bcb1dc830b84450ca25c8f57/ty-0.0.44-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:edd32b7467af509c99c0244c2226a4e4c03400699003ec33373282ab931654d9", size = 12091340, upload-time = "2026-06-05T03:33:36.289Z" },
+    { url = "https://files.pythonhosted.org/packages/16/c7/e1c9260ea5188195962ff1214ace418b5d69187e8fa7c0a1ec4994b8071b/ty-0.0.44-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:503a585f4007387c3afc58bae23a7ca1b9f236cbdb1a881dc36110655ceb1937", size = 11986201, upload-time = "2026-06-05T03:34:00.624Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f9/312bb112da9b1a7da295bb0426be85e72ad48da4e4266c36d77256b4058d/ty-0.0.44-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:2d28bcfa83243d77c2316944e8cf197f73597bf17d1ddc047d0b10a762531252", size = 12168475, upload-time = "2026-06-05T03:33:30.386Z" },
+    { url = "https://files.pythonhosted.org/packages/02/de/64978d603f6c3e5dd7cb97eca2214567d8ad0c85fa4a7435b7852ae4b779/ty-0.0.44-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:56fd2dd0192def189715b25f5338f6222fb827884dc34111e50aa1c4e061cee5", size = 11292937, upload-time = "2026-06-05T03:34:06.448Z" },
+    { url = "https://files.pythonhosted.org/packages/64/63/a625d8a3c71dcaa01988d330f849c465fe72ead4b0bbab44fe4bd6e672b5/ty-0.0.44-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7f8d990489032de1984e73c159f3e760d754cf83a602b874827d943821f63595", size = 11421560, upload-time = "2026-06-05T03:33:23.995Z" },
+    { url = "https://files.pythonhosted.org/packages/99/96/61aeba0e629b0c91bd316ff94d00e38817ec493ae4316f39508988daa287/ty-0.0.44-py3-none-musllinux_1_2_i686.whl", hash = "sha256:f61ffe72996a755432922fe90b28db593f572eb5cbf48e3ef4e67b282533d1b0", size = 11580282, upload-time = "2026-06-05T03:34:03.308Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f7/256e1538ce21cab67b381201444c42454de69d310059c4929d92a0ee9c48/ty-0.0.44-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:2b237a143bac4f30cec9257d45f01e72da97030a80a09a2b69cfef065f09c37f", size = 12085723, upload-time = "2026-06-05T03:33:45.953Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/76/ec3957c10872643a98db7a7895101ad89c5b7cba4bc6c4aebbbfc91756cc/ty-0.0.44-py3-none-win32.whl", hash = "sha256:6a24586c65419223ac5bab4822d49ab493a5d19ea2a897514284c232b9d6166a", size = 10892978, upload-time = "2026-06-05T03:34:12.603Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/7d/ba24050432196e7d7f03945e5c379951593c48e04e5c5d5275cfc4624791/ty-0.0.44-py3-none-win_amd64.whl", hash = "sha256:8cccb27e348c89a9733fbad1b2efadfbad79b107c7e52adb52dfd8a70156a38d", size = 11987058, upload-time = "2026-06-05T03:33:42.692Z" },
+    { url = "https://files.pythonhosted.org/packages/71/34/16ec3f1fec75292d9c56a8b5fef037ceaba85a5c30562206c1a245a00a67/ty-0.0.44-py3-none-win_arm64.whl", hash = "sha256:58049504e7a12bf1957f24a5384a332c94d5590127083a80db5e5a1bed34190b", size = 11329961, upload-time = "2026-06-05T03:33:39.427Z" },
 ]
 
 [[package]]
-name = "typing-extensions"
-version = "4.13.2"
+name = "types-protobuf"
+version = "7.35.1.20260906"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/6c/e3e5b3e10bc328126a39637c138f9ebfd734bf14342b9f3540039b4ab995/types_protobuf-7.35.1.20260906.tar.gz", hash = "sha256:efd1a3862d4c967dad5512ef8d56b1530ac84f182c41735b94004756518c4998", size = 69895, upload-time = "2026-09-06T06:35:28.308Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 },
+    { url = "https://files.pythonhosted.org/packages/44/4e/f63e826c68f77ef875506d72f225918800346545ee99847bc28f3394f18d/types_protobuf-7.35.1.20260906-py3-none-any.whl", hash = "sha256:5155e48569e0dabff303fdf578db96cd31ea9a4a63b18018a4ceac6b0ae17462", size = 86419, upload-time = "2026-09-06T06:35:27.247Z" },
 ]
 
 [[package]]
-name = "typing-inspection"
-version = "0.4.0"
+name = "types-requests"
+version = "2.33.0.20260518"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/82/5c/e6082df02e215b846b4b8c0b887a64d7d08ffaba30605502639d44c06b82/typing_inspection-0.4.0.tar.gz", hash = "sha256:9765c87de36671694a67904bf2c96e395be9c6439bb6c87b5142569dcdd65122", size = 76222 }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/01/c5a19253fe1ac159159ddf9a3a07cec8bb5e486ec4d9002ad2821da0e5d2/types_requests-2.33.0.20260518.tar.gz", hash = "sha256:df7bd3bfe0ca8402dfb841e7d9be714bb5578203283d66d7dc4ef69343449a5e", size = 24752, upload-time = "2026-05-18T06:07:37.966Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 },
+    { url = "https://files.pythonhosted.org/packages/1c/bc/b139710a3b6018f7fb2b9508b35c8af564e61bf2bf4fa619d088f3e16f85/types_requests-2.33.0.20260518-py3-none-any.whl", hash = "sha256:626d697d1adaaff76e2044dc8c5c051d8f21abc157bdfe204a75558076fe0bf0", size = 21391, upload-time = "2026-05-18T06:07:37.044Z" },
 ]
 
 [[package]]
-name = "tzdata"
-version = "2025.2"
+name = "typing-extensions"
+version = "4.15.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 }
+resolution-markers = [
+    "python_full_version >= '3.14'",
+    "python_full_version == '3.13.*'",
+    "python_full_version >= '3.11' and python_full_version < '3.13'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 },
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
 
 [[package]]
-name = "tzlocal"
-version = "5.3.1"
+name = "typing-extensions"
+version = "4.16.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "tzdata", marker = "sys_platform == 'win32'" },
+resolution-markers = [
+    "python_full_version < '3.11'",
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761 }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026 },
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
 ]
 
 [[package]]
-name = "uritemplate"
-version = "4.1.1"
+name = "typing-inspection"
+version = "0.4.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d2/5a/4742fdba39cd02a56226815abfa72fe0aa81c33bed16ed045647d6000eba/uritemplate-4.1.1.tar.gz", hash = "sha256:4346edfc5c3b79f694bccd6d6099a322bbeb628dbf2cd86eea55a456ce5124f0", size = 273898 }
+dependencies = [
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/c0/7461b49cd25aeece13766f02ee576d1db528f1c37ce69aee300e075b485b/uritemplate-4.1.1-py2.py3-none-any.whl", hash = "sha256:830c08b8d99bdd312ea4ead05994a38e8936266f84b9a7878232db50b044e02e", size = 10356 },
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
 [[package]]
 name = "urllib3"
-version = "2.4.0"
+version = "2.8.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672 }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680 },
+    { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" },
 ]
 
 [[package]]
-name = "uvicorn"
-version = "0.34.2"
+name = "uv-dynamic-versioning"
+version = "0.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "click" },
-    { name = "h11" },
+    { name = "dunamai" },
+    { name = "hatchling" },
+    { name = "jinja2" },
+    { name = "tomlkit" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a6/ae/9bbb19b9e1c450cf9ecaef06463e40234d98d95bf572fab11b4f19ae5ded/uvicorn-0.34.2.tar.gz", hash = "sha256:0e929828f6186353a80b58ea719861d2629d766293b6d19baf086ba31d4f3328", size = 76815 }
+sdist = { url = "https://files.pythonhosted.org/packages/15/ef/63270118de5af8f45ba417946290b63f86b0b2a7d07d739d5dc619462711/uv_dynamic_versioning-0.14.0.tar.gz", hash = "sha256:574fbc07e87ace45c01d55967ad3b864871257b98ff5b8ac87c261227ac8db5b", size = 47203, upload-time = "2026-03-22T04:53:36.374Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/4b/4cef6ce21a2aaca9d852a6e84ef4f135d99fcd74fa75105e2fc0c8308acd/uvicorn-0.34.2-py3-none-any.whl", hash = "sha256:deb49af569084536d269fe0a6d67e3754f104cf03aba7c11c40f01aadf33c403", size = 62483 },
+    { url = "https://files.pythonhosted.org/packages/89/39/35773a629ac27d8803ff5ed86bde89d06f77041d7afa0a06cdc584ee8c6f/uv_dynamic_versioning-0.14.0-py3-none-any.whl", hash = "sha256:e087c346a786e98d41292ac2315180fb700cedfb30565fc973d64ce11a112387", size = 12172, upload-time = "2026-03-22T04:53:35.063Z" },
 ]
 
 [[package]]
-name = "websockets"
-version = "15.0.1"
+name = "uvicorn"
+version = "0.49.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440 },
-    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098 },
-    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329 },
-    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111 },
-    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054 },
-    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496 },
-    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829 },
-    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217 },
-    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195 },
-    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393 },
-    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837 },
-    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743 },
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
-
-[[package]]
-name = "wrapt"
-version = "1.17.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800 },
-    { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824 },
-    { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920 },
-    { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690 },
-    { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861 },
-    { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174 },
-    { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721 },
-    { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763 },
-    { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585 },
-    { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676 },
-    { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871 },
-    { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312 },
-    { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062 },
-    { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155 },
-    { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471 },
-    { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208 },
-    { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339 },
-    { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232 },
-    { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476 },
-    { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377 },
-    { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986 },
-    { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750 },
-    { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594 },
-]
-
-[[package]]
-name = "xxhash"
-version = "3.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/00/5e/d6e5258d69df8b4ed8c83b6664f2b47d30d2dec551a29ad72a6c69eafd31/xxhash-3.5.0.tar.gz", hash = "sha256:84f2caddf951c9cbf8dc2e22a89d4ccf5d86391ac6418fe81e3c67d0cf60b45f", size = 84241 }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/1f/fa18009dea8469069cca78a4e877a008ab78f08b064bfc9ab891579077ff/uvicorn-0.49.0.tar.gz", hash = "sha256:ebf4271aa580d9de97f93192d4595176df6e91f9aae919ca73e4fc07df1e66a3", size = 91284, upload-time = "2026-06-03T22:01:30.448Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c9/b8/e4b3ad92d249be5c83fa72916c9091b0965cb0faeff05d9a0a3870ae6bff/xxhash-3.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37889a0d13b0b7d739cfc128b1c902f04e32de17b33d74b637ad42f1c55101f6", size = 31795 },
-    { url = "https://files.pythonhosted.org/packages/fc/d8/b3627a0aebfbfa4c12a41e22af3742cf08c8ea84f5cc3367b5de2d039cce/xxhash-3.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:97a662338797c660178e682f3bc180277b9569a59abfb5925e8620fba00b9fc5", size = 30792 },
-    { url = "https://files.pythonhosted.org/packages/c3/cc/762312960691da989c7cd0545cb120ba2a4148741c6ba458aa723c00a3f8/xxhash-3.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f85e0108d51092bdda90672476c7d909c04ada6923c14ff9d913c4f7dc8a3bc", size = 220950 },
-    { url = "https://files.pythonhosted.org/packages/fe/e9/cc266f1042c3c13750e86a535496b58beb12bf8c50a915c336136f6168dc/xxhash-3.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd2fd827b0ba763ac919440042302315c564fdb797294d86e8cdd4578e3bc7f3", size = 199980 },
-    { url = "https://files.pythonhosted.org/packages/bf/85/a836cd0dc5cc20376de26b346858d0ac9656f8f730998ca4324921a010b9/xxhash-3.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82085c2abec437abebf457c1d12fccb30cc8b3774a0814872511f0f0562c768c", size = 428324 },
-    { url = "https://files.pythonhosted.org/packages/b4/0e/15c243775342ce840b9ba34aceace06a1148fa1630cd8ca269e3223987f5/xxhash-3.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07fda5de378626e502b42b311b049848c2ef38784d0d67b6f30bb5008642f8eb", size = 194370 },
-    { url = "https://files.pythonhosted.org/packages/87/a1/b028bb02636dfdc190da01951d0703b3d904301ed0ef6094d948983bef0e/xxhash-3.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c279f0d2b34ef15f922b77966640ade58b4ccdfef1c4d94b20f2a364617a493f", size = 207911 },
-    { url = "https://files.pythonhosted.org/packages/80/d5/73c73b03fc0ac73dacf069fdf6036c9abad82de0a47549e9912c955ab449/xxhash-3.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:89e66ceed67b213dec5a773e2f7a9e8c58f64daeb38c7859d8815d2c89f39ad7", size = 216352 },
-    { url = "https://files.pythonhosted.org/packages/b6/2a/5043dba5ddbe35b4fe6ea0a111280ad9c3d4ba477dd0f2d1fe1129bda9d0/xxhash-3.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bcd51708a633410737111e998ceb3b45d3dbc98c0931f743d9bb0a209033a326", size = 203410 },
-    { url = "https://files.pythonhosted.org/packages/a2/b2/9a8ded888b7b190aed75b484eb5c853ddd48aa2896e7b59bbfbce442f0a1/xxhash-3.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ff2c0a34eae7df88c868be53a8dd56fbdf592109e21d4bfa092a27b0bf4a7bf", size = 210322 },
-    { url = "https://files.pythonhosted.org/packages/98/62/440083fafbc917bf3e4b67c2ade621920dd905517e85631c10aac955c1d2/xxhash-3.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:4e28503dccc7d32e0b9817aa0cbfc1f45f563b2c995b7a66c4c8a0d232e840c7", size = 414725 },
-    { url = "https://files.pythonhosted.org/packages/75/db/009206f7076ad60a517e016bb0058381d96a007ce3f79fa91d3010f49cc2/xxhash-3.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a6c50017518329ed65a9e4829154626f008916d36295b6a3ba336e2458824c8c", size = 192070 },
-    { url = "https://files.pythonhosted.org/packages/1f/6d/c61e0668943a034abc3a569cdc5aeae37d686d9da7e39cf2ed621d533e36/xxhash-3.5.0-cp313-cp313-win32.whl", hash = "sha256:53a068fe70301ec30d868ece566ac90d873e3bb059cf83c32e76012c889b8637", size = 30172 },
-    { url = "https://files.pythonhosted.org/packages/96/14/8416dce965f35e3d24722cdf79361ae154fa23e2ab730e5323aa98d7919e/xxhash-3.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:80babcc30e7a1a484eab952d76a4f4673ff601f54d5142c26826502740e70b43", size = 30041 },
-    { url = "https://files.pythonhosted.org/packages/27/ee/518b72faa2073f5aa8e3262408d284892cb79cf2754ba0c3a5870645ef73/xxhash-3.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:4811336f1ce11cac89dcbd18f3a25c527c16311709a89313c3acaf771def2d4b", size = 26801 },
+    { url = "https://files.pythonhosted.org/packages/88/fa/e1388bbcf24ef3274f45c0c1c7b501fd14971037c1b6ee23610553307497/uvicorn-0.49.0-py3-none-any.whl", hash = "sha256:ba3d14c3ee7e41c6c654c46c9eb489d33213cdd30aa1696eab1374337c13f68f", size = 71376, upload-time = "2026-06-03T22:01:29.037Z" },
 ]
 
 [[package]]
-name = "zipp"
-version = "3.21.0"
+name = "virtualenv"
+version = "21.14.13"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+    { name = "typing-extensions", version = "4.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/70/aa/bff50daee0488e16d611258a9b6c5a1d0c9e128f8ca424e9f4e1c0444ef2/virtualenv-21.14.13.tar.gz", hash = "sha256:de5307ba4b9a0001d9c8ea02832d38f63ca432880f416c1bface61c4323fd905", size = 5570301, upload-time = "2026-10-22T20:10:16.952Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 },
+    { url = "https://files.pythonhosted.org/packages/bb/a9/c10d8a44a29fb94a18b43fdf11f38caca53ae7c9406f11a72b1cb8f624f1/virtualenv-21.14.13-py3-none-any.whl", hash = "sha256:5fbb04138a4861580b78ba9110d529a26bc48fcc93c8ec36bc0202eeed96a788", size = 5557094, upload-time = "2026-10-22T20:10:15.096Z" },
 ]
 
 [[package]]
-name = "zstandard"
-version = "0.23.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation == 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ed/f6/2ac0287b442160a89d726b17a9184a4c615bb5237db763791a7fd16d9df1/zstandard-0.23.0.tar.gz", hash = "sha256:b2d8c62d08e7255f68f7a740bae85b3c9b8e5466baa9cbf7f57f1cde0ac6bc09", size = 681701 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/80/f1/8386f3f7c10261fe85fbc2c012fdb3d4db793b921c9abcc995d8da1b7a80/zstandard-0.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:576856e8594e6649aee06ddbfc738fec6a834f7c85bf7cadd1c53d4a58186ef9", size = 788975 },
-    { url = "https://files.pythonhosted.org/packages/16/e8/cbf01077550b3e5dc86089035ff8f6fbbb312bc0983757c2d1117ebba242/zstandard-0.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38302b78a850ff82656beaddeb0bb989a0322a8bbb1bf1ab10c17506681d772a", size = 633448 },
-    { url = "https://files.pythonhosted.org/packages/06/27/4a1b4c267c29a464a161aeb2589aff212b4db653a1d96bffe3598f3f0d22/zstandard-0.23.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2240ddc86b74966c34554c49d00eaafa8200a18d3a5b6ffbf7da63b11d74ee2", size = 4945269 },
-    { url = "https://files.pythonhosted.org/packages/7c/64/d99261cc57afd9ae65b707e38045ed8269fbdae73544fd2e4a4d50d0ed83/zstandard-0.23.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ef230a8fd217a2015bc91b74f6b3b7d6522ba48be29ad4ea0ca3a3775bf7dd5", size = 5306228 },
-    { url = "https://files.pythonhosted.org/packages/7a/cf/27b74c6f22541f0263016a0fd6369b1b7818941de639215c84e4e94b2a1c/zstandard-0.23.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:774d45b1fac1461f48698a9d4b5fa19a69d47ece02fa469825b442263f04021f", size = 5336891 },
-    { url = "https://files.pythonhosted.org/packages/fa/18/89ac62eac46b69948bf35fcd90d37103f38722968e2981f752d69081ec4d/zstandard-0.23.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f77fa49079891a4aab203d0b1744acc85577ed16d767b52fc089d83faf8d8ed", size = 5436310 },
-    { url = "https://files.pythonhosted.org/packages/a8/a8/5ca5328ee568a873f5118d5b5f70d1f36c6387716efe2e369010289a5738/zstandard-0.23.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac184f87ff521f4840e6ea0b10c0ec90c6b1dcd0bad2f1e4a9a1b4fa177982ea", size = 4859912 },
-    { url = "https://files.pythonhosted.org/packages/ea/ca/3781059c95fd0868658b1cf0440edd832b942f84ae60685d0cfdb808bca1/zstandard-0.23.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c363b53e257246a954ebc7c488304b5592b9c53fbe74d03bc1c64dda153fb847", size = 4936946 },
-    { url = "https://files.pythonhosted.org/packages/ce/11/41a58986f809532742c2b832c53b74ba0e0a5dae7e8ab4642bf5876f35de/zstandard-0.23.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:e7792606d606c8df5277c32ccb58f29b9b8603bf83b48639b7aedf6df4fe8171", size = 5466994 },
-    { url = "https://files.pythonhosted.org/packages/83/e3/97d84fe95edd38d7053af05159465d298c8b20cebe9ccb3d26783faa9094/zstandard-0.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a0817825b900fcd43ac5d05b8b3079937073d2b1ff9cf89427590718b70dd840", size = 4848681 },
-    { url = "https://files.pythonhosted.org/packages/6e/99/cb1e63e931de15c88af26085e3f2d9af9ce53ccafac73b6e48418fd5a6e6/zstandard-0.23.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:9da6bc32faac9a293ddfdcb9108d4b20416219461e4ec64dfea8383cac186690", size = 4694239 },
-    { url = "https://files.pythonhosted.org/packages/ab/50/b1e703016eebbc6501fc92f34db7b1c68e54e567ef39e6e59cf5fb6f2ec0/zstandard-0.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fd7699e8fd9969f455ef2926221e0233f81a2542921471382e77a9e2f2b57f4b", size = 5200149 },
-    { url = "https://files.pythonhosted.org/packages/aa/e0/932388630aaba70197c78bdb10cce2c91fae01a7e553b76ce85471aec690/zstandard-0.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d477ed829077cd945b01fc3115edd132c47e6540ddcd96ca169facff28173057", size = 5655392 },
-    { url = "https://files.pythonhosted.org/packages/02/90/2633473864f67a15526324b007a9f96c96f56d5f32ef2a56cc12f9548723/zstandard-0.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa6ce8b52c5987b3e34d5674b0ab529a4602b632ebab0a93b07bfb4dfc8f8a33", size = 5191299 },
-    { url = "https://files.pythonhosted.org/packages/b0/4c/315ca5c32da7e2dc3455f3b2caee5c8c2246074a61aac6ec3378a97b7136/zstandard-0.23.0-cp313-cp313-win32.whl", hash = "sha256:a9b07268d0c3ca5c170a385a0ab9fb7fdd9f5fd866be004c4ea39e44edce47dd", size = 430862 },
-    { url = "https://files.pythonhosted.org/packages/a2/bf/c6aaba098e2d04781e8f4f7c0ba3c7aa73d00e4c436bcc0cf059a66691d1/zstandard-0.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:f3513916e8c645d0610815c257cbfd3242adfd5c4cfa78be514e5a3ebb42a41b", size = 495578 },
+name = "wrapt"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/64/925f213fdcbb9baeb1530449ac71a4d57fc361c053d06bf78d0c5c7cd80c/wrapt-2.1.2.tar.gz", hash = "sha256:3996a67eecc2c68fd47b4e3c564405a5777367adfd9b8abb58387b63ee83b21e", size = 81678, upload-time = "2026-03-06T02:53:25.134Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/d2/387594fb592d027366645f3d7cc9b4d7ca7be93845fbaba6d835a912ef3c/wrapt-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4b7a86d99a14f76facb269dc148590c01aaf47584071809a70da30555228158c", size = 60669, upload-time = "2026-03-06T02:52:40.671Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/18/3f373935bc5509e7ac444c8026a56762e50c1183e7061797437ca96c12ce/wrapt-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a819e39017f95bf7aede768f75915635aa8f671f2993c036991b8d3bfe8dbb6f", size = 61603, upload-time = "2026-03-06T02:54:21.032Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/7a/32758ca2853b07a887a4574b74e28843919103194bb47001a304e24af62f/wrapt-2.1.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5681123e60aed0e64c7d44f72bbf8b4ce45f79d81467e2c4c728629f5baf06eb", size = 113632, upload-time = "2026-03-06T02:53:54.121Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d5/eeaa38f670d462e97d978b3b0d9ce06d5b91e54bebac6fbed867809216e7/wrapt-2.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b8b28e97a44d21836259739ae76284e180b18abbb4dcfdff07a415cf1016c3e", size = 115644, upload-time = "2026-03-06T02:54:53.33Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/09/2a41506cb17affb0bdf9d5e2129c8c19e192b388c4c01d05e1b14db23c00/wrapt-2.1.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cef91c95a50596fcdc31397eb6955476f82ae8a3f5a8eabdc13611b60ee380ba", size = 112016, upload-time = "2026-03-06T02:54:43.274Z" },
+    { url = "https://files.pythonhosted.org/packages/64/15/0e6c3f5e87caadc43db279724ee36979246d5194fa32fed489c73643ba59/wrapt-2.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dad63212b168de8569b1c512f4eac4b57f2c6934b30df32d6ee9534a79f1493f", size = 114823, upload-time = "2026-03-06T02:54:29.392Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b2/0ad17c8248f4e57bedf44938c26ec3ee194715f812d2dbbd9d7ff4be6c06/wrapt-2.1.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d307aa6888d5efab2c1cde09843d48c843990be13069003184b67d426d145394", size = 111244, upload-time = "2026-03-06T02:54:02.149Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/04/bcdba98c26f2c6522c7c09a726d5d9229120163493620205b2f76bd13c01/wrapt-2.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c87cf3f0c85e27b3ac7d9ad95da166bf8739ca215a8b171e8404a2d739897a45", size = 113307, upload-time = "2026-03-06T02:54:12.428Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/1b/5e2883c6bc14143924e465a6fc5a92d09eeabe35310842a481fb0581f832/wrapt-2.1.2-cp310-cp310-win32.whl", hash = "sha256:d1c5fea4f9fe3762e2b905fdd67df51e4be7a73b7674957af2d2ade71a5c075d", size = 57986, upload-time = "2026-03-06T02:54:26.823Z" },
+    { url = "https://files.pythonhosted.org/packages/42/5a/4efc997bccadd3af5749c250b49412793bc41e13a83a486b2b54a33e240c/wrapt-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:d8f7740e1af13dff2684e4d56fe604a7e04d6c94e737a60568d8d4238b9a0c71", size = 60336, upload-time = "2026-03-06T02:54:18Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/f5/a2bb833e20181b937e87c242645ed5d5aa9c373006b0467bfe1a35c727d0/wrapt-2.1.2-cp310-cp310-win_arm64.whl", hash = "sha256:1c6cc827c00dc839350155f316f1f8b4b0c370f52b6a19e782e2bda89600c7dc", size = 58757, upload-time = "2026-03-06T02:53:51.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/81/60c4471fce95afa5922ca09b88a25f03c93343f759aae0f31fb4412a85c7/wrapt-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:96159a0ee2b0277d44201c3b5be479a9979cf154e8c82fa5df49586a8e7679bb", size = 60666, upload-time = "2026-03-06T02:52:58.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/be/80e80e39e7cb90b006a0eaf11c73ac3a62bbfb3068469aec15cc0bc795de/wrapt-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:98ba61833a77b747901e9012072f038795de7fc77849f1faa965464f3f87ff2d", size = 61601, upload-time = "2026-03-06T02:53:00.487Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/be/d7c88cd9293c859fc74b232abdc65a229bb953997995d6912fc85af18323/wrapt-2.1.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:767c0dbbe76cae2a60dd2b235ac0c87c9cccf4898aef8062e57bead46b5f6894", size = 114057, upload-time = "2026-03-06T02:52:44.08Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/25/36c04602831a4d685d45a93b3abea61eca7fe35dab6c842d6f5d570ef94a/wrapt-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c691a6bc752c0cc4711cc0c00896fcd0f116abc253609ef64ef930032821842", size = 116099, upload-time = "2026-03-06T02:54:56.74Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/4e/98a6eb417ef551dc277bec1253d5246b25003cf36fdf3913b65cb7657a56/wrapt-2.1.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f3b7d73012ea75aee5844de58c88f44cf62d0d62711e39da5a82824a7c4626a8", size = 112457, upload-time = "2026-03-06T02:53:52.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/a6/a6f7186a5297cad8ec53fd7578533b28f795fdf5372368c74bd7e6e9841c/wrapt-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:577dff354e7acd9d411eaf4bfe76b724c89c89c8fc9b7e127ee28c5f7bcb25b6", size = 115351, upload-time = "2026-03-06T02:53:32.684Z" },
+    { url = "https://files.pythonhosted.org/packages/97/6f/06e66189e721dbebd5cf20e138acc4d1150288ce118462f2fcbff92d38db/wrapt-2.1.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3d7b6fd105f8b24e5bd23ccf41cb1d1099796524bcc6f7fbb8fe576c44befbc9", size = 111748, upload-time = "2026-03-06T02:53:08.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/43/4808b86f499a51370fbdbdfa6cb91e9b9169e762716456471b619fca7a70/wrapt-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:866abdbf4612e0b34764922ef8b1c5668867610a718d3053d59e24a5e5fcfc15", size = 113783, upload-time = "2026-03-06T02:53:02.02Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2c/a3f28b8fa7ac2cefa01cfcaca3471f9b0460608d012b693998cd61ef43df/wrapt-2.1.2-cp311-cp311-win32.whl", hash = "sha256:5a0a0a3a882393095573344075189eb2d566e0fd205a2b6414e9997b1b800a8b", size = 57977, upload-time = "2026-03-06T02:53:27.844Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/c3/2b1c7bd07a27b1db885a2fab469b707bdd35bddf30a113b4917a7e2139d2/wrapt-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:64a07a71d2730ba56f11d1a4b91f7817dc79bc134c11516b75d1921a7c6fcda1", size = 60336, upload-time = "2026-03-06T02:54:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/5c/76ece7b401b088daa6503d6264dd80f9a727df3e6042802de9a223084ea2/wrapt-2.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:b89f095fe98bc12107f82a9f7d570dc83a0870291aeb6b1d7a7d35575f55d98a", size = 58756, upload-time = "2026-03-06T02:53:16.319Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/b6/1db817582c49c7fcbb7df6809d0f515af29d7c2fbf57eb44c36e98fb1492/wrapt-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ff2aad9c4cda28a8f0653fc2d487596458c2a3f475e56ba02909e950a9efa6a9", size = 61255, upload-time = "2026-03-06T02:52:45.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/16/9b02a6b99c09227c93cd4b73acc3678114154ec38da53043c0ddc1fba0dc/wrapt-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6433ea84e1cfacf32021d2a4ee909554ade7fd392caa6f7c13f1f4bf7b8e8748", size = 61848, upload-time = "2026-03-06T02:53:48.728Z" },
+    { url = "https://files.pythonhosted.org/packages/af/aa/ead46a88f9ec3a432a4832dfedb84092fc35af2d0ba40cd04aea3889f247/wrapt-2.1.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c20b757c268d30d6215916a5fa8461048d023865d888e437fab451139cad6c8e", size = 121433, upload-time = "2026-03-06T02:54:40.328Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/9f/742c7c7cdf58b59085a1ee4b6c37b013f66ac33673a7ef4aaed5e992bc33/wrapt-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79847b83eb38e70d93dc392c7c5b587efe65b3e7afcc167aa8abd5d60e8761c8", size = 123013, upload-time = "2026-03-06T02:53:26.58Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/44/2c3dd45d53236b7ed7c646fcf212251dc19e48e599debd3926b52310fafb/wrapt-2.1.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f8fba1bae256186a83d1875b2b1f4e2d1242e8fac0f58ec0d7e41b26967b965c", size = 117326, upload-time = "2026-03-06T02:53:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/74/e2/b17d66abc26bd96f89dec0ecd0ef03da4a1286e6ff793839ec431b9fae57/wrapt-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e3d3b35eedcf5f7d022291ecd7533321c4775f7b9cd0050a31a68499ba45757c", size = 121444, upload-time = "2026-03-06T02:54:09.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/62/e2977843fdf9f03daf1586a0ff49060b1b2fc7ff85a7ea82b6217c1ae36e/wrapt-2.1.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6f2c5390460de57fa9582bc8a1b7a6c86e1a41dfad74c5225fc07044c15cc8d1", size = 116237, upload-time = "2026-03-06T02:54:03.884Z" },
+    { url = "https://files.pythonhosted.org/packages/88/dd/27fc67914e68d740bce512f11734aec08696e6b17641fef8867c00c949fc/wrapt-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7dfa9f2cf65d027b951d05c662cc99ee3bd01f6e4691ed39848a7a5fffc902b2", size = 120563, upload-time = "2026-03-06T02:53:20.412Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/9f/b750b3692ed2ef4705cb305bd68858e73010492b80e43d2a4faa5573cbe7/wrapt-2.1.2-cp312-cp312-win32.whl", hash = "sha256:eba8155747eb2cae4a0b913d9ebd12a1db4d860fc4c829d7578c7b989bd3f2f0", size = 58198, upload-time = "2026-03-06T02:53:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/b2/feecfe29f28483d888d76a48f03c4c4d8afea944dbee2b0cd3380f9df032/wrapt-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1c51c738d7d9faa0b3601708e7e2eda9bf779e1b601dce6c77411f2a1b324a63", size = 60441, upload-time = "2026-03-06T02:52:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/44/e1/e328f605d6e208547ea9fd120804fcdec68536ac748987a68c47c606eea8/wrapt-2.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:c8e46ae8e4032792eb2f677dbd0d557170a8e5524d22acc55199f43efedd39bf", size = 58836, upload-time = "2026-03-06T02:53:22.053Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/7a/d936840735c828b38d26a854e85d5338894cda544cb7a85a9d5b8b9c4df7/wrapt-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:787fd6f4d67befa6fe2abdffcbd3de2d82dfc6fb8a6d850407c53332709d030b", size = 61259, upload-time = "2026-03-06T02:53:41.922Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/88/9a9b9a90ac8ca11c2fdb6a286cb3a1fc7dd774c00ed70929a6434f6bc634/wrapt-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4bdf26e03e6d0da3f0e9422fd36bcebf7bc0eeb55fdf9c727a09abc6b9fe472e", size = 61851, upload-time = "2026-03-06T02:52:48.672Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a9/5b7d6a16fd6533fed2756900fc8fc923f678179aea62ada6d65c92718c00/wrapt-2.1.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bbac24d879aa22998e87f6b3f481a5216311e7d53c7db87f189a7a0266dafffb", size = 121446, upload-time = "2026-03-06T02:54:14.013Z" },
+    { url = "https://files.pythonhosted.org/packages/45/bb/34c443690c847835cfe9f892be78c533d4f32366ad2888972c094a897e39/wrapt-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16997dfb9d67addc2e3f41b62a104341e80cac52f91110dece393923c0ebd5ca", size = 123056, upload-time = "2026-03-06T02:54:10.829Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b9/ff205f391cb708f67f41ea148545f2b53ff543a7ac293b30d178af4d2271/wrapt-2.1.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:162e4e2ba7542da9027821cb6e7c5e068d64f9a10b5f15512ea28e954893a267", size = 117359, upload-time = "2026-03-06T02:53:03.623Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/3d/1ea04d7747825119c3c9a5e0874a40b33594ada92e5649347c457d982805/wrapt-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f29c827a8d9936ac320746747a016c4bc66ef639f5cd0d32df24f5eacbf9c69f", size = 121479, upload-time = "2026-03-06T02:53:45.844Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cc/ee3a011920c7a023b25e8df26f306b2484a531ab84ca5c96260a73de76c0/wrapt-2.1.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a9dd9813825f7ecb018c17fd147a01845eb330254dff86d3b5816f20f4d6aaf8", size = 116271, upload-time = "2026-03-06T02:54:46.356Z" },
+    { url = "https://files.pythonhosted.org/packages/98/fd/e5ff7ded41b76d802cf1191288473e850d24ba2e39a6ec540f21ae3b57cb/wrapt-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f8dbdd3719e534860d6a78526aafc220e0241f981367018c2875178cf83a413", size = 120573, upload-time = "2026-03-06T02:52:50.163Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c5/242cae3b5b080cd09bacef0591691ba1879739050cc7c801ff35c8886b66/wrapt-2.1.2-cp313-cp313-win32.whl", hash = "sha256:5c35b5d82b16a3bc6e0a04349b606a0582bc29f573786aebe98e0c159bc48db6", size = 58205, upload-time = "2026-03-06T02:53:47.494Z" },
+    { url = "https://files.pythonhosted.org/packages/12/69/c358c61e7a50f290958809b3c61ebe8b3838ea3e070d7aac9814f95a0528/wrapt-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:f8bc1c264d8d1cf5b3560a87bbdd31131573eb25f9f9447bb6252b8d4c44a3a1", size = 60452, upload-time = "2026-03-06T02:53:30.038Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/66/c8a6fcfe321295fd8c0ab1bd685b5a01462a9b3aa2f597254462fc2bc975/wrapt-2.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:3beb22f674550d5634642c645aba4c72a2c66fb185ae1aebe1e955fae5a13baf", size = 58842, upload-time = "2026-03-06T02:52:52.114Z" },
+    { url = "https://files.pythonhosted.org/packages/da/55/9c7052c349106e0b3f17ae8db4b23a691a963c334de7f9dbd60f8f74a831/wrapt-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fc04bc8664a8bc4c8e00b37b5355cffca2535209fba1abb09ae2b7c76ddf82b", size = 63075, upload-time = "2026-03-06T02:53:19.108Z" },
+    { url = "https://files.pythonhosted.org/packages/09/a8/ce7b4006f7218248dd71b7b2b732d0710845a0e49213b18faef64811ffef/wrapt-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a9b9d50c9af998875a1482a038eb05755dfd6fe303a313f6a940bb53a83c3f18", size = 63719, upload-time = "2026-03-06T02:54:33.452Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e5/2ca472e80b9e2b7a17f106bb8f9df1db11e62101652ce210f66935c6af67/wrapt-2.1.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2d3ff4f0024dd224290c0eabf0240f1bfc1f26363431505fb1b0283d3b08f11d", size = 152643, upload-time = "2026-03-06T02:52:42.721Z" },
+    { url = "https://files.pythonhosted.org/packages/36/42/30f0f2cefca9d9cbf6835f544d825064570203c3e70aa873d8ae12e23791/wrapt-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3278c471f4468ad544a691b31bb856374fbdefb7fee1a152153e64019379f015", size = 158805, upload-time = "2026-03-06T02:54:25.441Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/67/d08672f801f604889dcf58f1a0b424fe3808860ede9e03affc1876b295af/wrapt-2.1.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8914c754d3134a3032601c6984db1c576e6abaf3fc68094bb8ab1379d75ff92", size = 145990, upload-time = "2026-03-06T02:53:57.456Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a7/fd371b02e73babec1de6ade596e8cd9691051058cfdadbfd62a5898f3295/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ff95d4264e55839be37bafe1536db2ab2de19da6b65f9244f01f332b5286cfbf", size = 155670, upload-time = "2026-03-06T02:54:55.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/2d/9fe0095dfdb621009f40117dcebf41d7396c2c22dca6eac779f4c007b86c/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:76405518ca4e1b76fbb1b9f686cff93aebae03920cc55ceeec48ff9f719c5f67", size = 144357, upload-time = "2026-03-06T02:54:24.092Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b6/ec7b4a254abbe4cde9fa15c5d2cca4518f6b07d0f1b77d4ee9655e30280e/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c0be8b5a74c5824e9359b53e7e58bef71a729bacc82e16587db1c4ebc91f7c5a", size = 150269, upload-time = "2026-03-06T02:53:31.268Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6b/2fabe8ebf148f4ee3c782aae86a795cc68ffe7d432ef550f234025ce0cfa/wrapt-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:f01277d9a5fc1862f26f7626da9cf443bebc0abd2f303f41c5e995b15887dabd", size = 59894, upload-time = "2026-03-06T02:54:15.391Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/fb/9ba66fc2dedc936de5f8073c0217b5d4484e966d87723415cc8262c5d9c2/wrapt-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:84ce8f1c2104d2f6daa912b1b5b039f331febfeee74f8042ad4e04992bd95c8f", size = 63197, upload-time = "2026-03-06T02:54:41.943Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1c/012d7423c95d0e337117723eb8ecf73c622ce15a97847e84cf3f8f26cd7e/wrapt-2.1.2-cp313-cp313t-win_arm64.whl", hash = "sha256:a93cd767e37faeddbe07d8fc4212d5cba660af59bdb0f6372c93faaa13e6e679", size = 60363, upload-time = "2026-03-06T02:54:48.093Z" },
+    { url = "https://files.pythonhosted.org/packages/39/25/e7ea0b417db02bb796182a5316398a75792cd9a22528783d868755e1f669/wrapt-2.1.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1370e516598854e5b4366e09ce81e08bfe94d42b0fd569b88ec46cc56d9164a9", size = 61418, upload-time = "2026-03-06T02:53:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/0f/fa539e2f6a770249907757eaeb9a5ff4deb41c026f8466c1c6d799088a9b/wrapt-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6de1a3851c27e0bd6a04ca993ea6f80fc53e6c742ee1601f486c08e9f9b900a9", size = 61914, upload-time = "2026-03-06T02:52:53.37Z" },
+    { url = "https://files.pythonhosted.org/packages/53/37/02af1867f5b1441aaeda9c82deed061b7cd1372572ddcd717f6df90b5e93/wrapt-2.1.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:de9f1a2bbc5ac7f6012ec24525bdd444765a2ff64b5985ac6e0692144838542e", size = 120417, upload-time = "2026-03-06T02:54:30.74Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/b7/0138a6238c8ba7476c77cf786a807f871672b37f37a422970342308276e7/wrapt-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:970d57ed83fa040d8b20c52fe74a6ae7e3775ae8cff5efd6a81e06b19078484c", size = 122797, upload-time = "2026-03-06T02:54:51.539Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/ad/819ae558036d6a15b7ed290d5b14e209ca795dd4da9c58e50c067d5927b0/wrapt-2.1.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3969c56e4563c375861c8df14fa55146e81ac11c8db49ea6fb7f2ba58bc1ff9a", size = 117350, upload-time = "2026-03-06T02:54:37.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/2d/afc18dc57a4600a6e594f77a9ae09db54f55ba455440a54886694a84c71b/wrapt-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:57d7c0c980abdc5f1d98b11a2aa3bb159790add80258c717fa49a99921456d90", size = 121223, upload-time = "2026-03-06T02:54:35.221Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/5b/5ec189b22205697bc56eb3b62aed87a1e0423e9c8285d0781c7a83170d15/wrapt-2.1.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:776867878e83130c7a04237010463372e877c1c994d449ca6aaafeab6aab2586", size = 116287, upload-time = "2026-03-06T02:54:19.654Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/2d/f84939a7c9b5e6cdd8a8d0f6a26cabf36a0f7e468b967720e8b0cd2bdf69/wrapt-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fab036efe5464ec3291411fabb80a7a39e2dd80bae9bcbeeca5087fdfa891e19", size = 119593, upload-time = "2026-03-06T02:54:16.697Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/fe/ccd22a1263159c4ac811ab9374c061bcb4a702773f6e06e38de5f81a1bdc/wrapt-2.1.2-cp314-cp314-win32.whl", hash = "sha256:e6ed62c82ddf58d001096ae84ce7f833db97ae2263bff31c9b336ba8cfe3f508", size = 58631, upload-time = "2026-03-06T02:53:06.498Z" },
+    { url = "https://files.pythonhosted.org/packages/65/0a/6bd83be7bff2e7efaac7b4ac9748da9d75a34634bbbbc8ad077d527146df/wrapt-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:467e7c76315390331c67073073d00662015bb730c566820c9ca9b54e4d67fd04", size = 60875, upload-time = "2026-03-06T02:53:50.252Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/c0/0b3056397fe02ff80e5a5d72d627c11eb885d1ca78e71b1a5c1e8c7d45de/wrapt-2.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:da1f00a557c66225d53b095a97eace0fc5349e3bfda28fa34ffae238978ee575", size = 59164, upload-time = "2026-03-06T02:53:59.128Z" },
+    { url = "https://files.pythonhosted.org/packages/71/ed/5d89c798741993b2371396eb9d4634f009ff1ad8a6c78d366fe2883ea7a6/wrapt-2.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:62503ffbc2d3a69891cf29beeaccdb4d5e0a126e2b6a851688d4777e01428dbb", size = 63163, upload-time = "2026-03-06T02:52:54.873Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/8c/05d277d182bf36b0a13d6bd393ed1dec3468a25b59d01fba2dd70fe4d6ae/wrapt-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c7e6cd120ef837d5b6f860a6ea3745f8763805c418bb2f12eeb1fa6e25f22d22", size = 63723, upload-time = "2026-03-06T02:52:56.374Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/27/6c51ec1eff4413c57e72d6106bb8dec6f0c7cdba6503d78f0fa98767bcc9/wrapt-2.1.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3769a77df8e756d65fbc050333f423c01ae012b4f6731aaf70cf2bef61b34596", size = 152652, upload-time = "2026-03-06T02:53:23.79Z" },
+    { url = "https://files.pythonhosted.org/packages/db/4c/d7dd662d6963fc7335bfe29d512b02b71cdfa23eeca7ab3ac74a67505deb/wrapt-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a76d61a2e851996150ba0f80582dd92a870643fa481f3b3846f229de88caf044", size = 158807, upload-time = "2026-03-06T02:53:35.742Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/4d/1e5eea1a78d539d346765727422976676615814029522c76b87a95f6bcdd/wrapt-2.1.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6f97edc9842cf215312b75fe737ee7c8adda75a89979f8e11558dfff6343cc4b", size = 146061, upload-time = "2026-03-06T02:52:57.574Z" },
+    { url = "https://files.pythonhosted.org/packages/89/bc/62cabea7695cd12a288023251eeefdcb8465056ddaab6227cb78a2de005b/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4006c351de6d5007aa33a551f600404ba44228a89e833d2fadc5caa5de8edfbf", size = 155667, upload-time = "2026-03-06T02:53:39.422Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/99/6f2888cd68588f24df3a76572c69c2de28287acb9e1972bf0c83ce97dbc1/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:a9372fc3639a878c8e7d87e1556fa209091b0a66e912c611e3f833e2c4202be2", size = 144392, upload-time = "2026-03-06T02:54:22.41Z" },
+    { url = "https://files.pythonhosted.org/packages/40/51/1dfc783a6c57971614c48e361a82ca3b6da9055879952587bc99fe1a7171/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3144b027ff30cbd2fca07c0a87e67011adb717eb5f5bd8496325c17e454257a3", size = 150296, upload-time = "2026-03-06T02:54:07.848Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/38/cbb8b933a0201076c1f64fc42883b0023002bdc14a4964219154e6ff3350/wrapt-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:3b8d15e52e195813efe5db8cec156eebe339aaf84222f4f4f051a6c01f237ed7", size = 60539, upload-time = "2026-03-06T02:54:00.594Z" },
+    { url = "https://files.pythonhosted.org/packages/82/dd/e5176e4b241c9f528402cebb238a36785a628179d7d8b71091154b3e4c9e/wrapt-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:08ffa54146a7559f5b8df4b289b46d963a8e74ed16ba3687f99896101a3990c5", size = 63969, upload-time = "2026-03-06T02:54:39Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/99/79f17046cf67e4a95b9987ea129632ba8bcec0bc81f3fb3d19bdb0bd60cd/wrapt-2.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:72aaa9d0d8e4ed0e2e98019cea47a21f823c9dd4b43c7b77bba6679ffcca6a00", size = 60554, upload-time = "2026-03-06T02:53:14.132Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/c7/8528ac2dfa2c1e6708f647df7ae144ead13f0a31146f43c7264b4942bf12/wrapt-2.1.2-py3-none-any.whl", hash = "sha256:b8fd6fa2b2c4e7621808f8c62e8317f4aae56e59721ad933bac5239d913cf0e8", size = 43993, upload-time = "2026-03-06T02:53:12.905Z" },
 ]