release v1

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+.ruff_cache/
+.pytest_cache/
+uv.lock
+.envrc
+# raw per-run captures + eval outputs are intermediates; the published artifact is data/*.parquet
+results/

.python-version

@@ -0,0 +1 @@
+3.13

DATASHEET.md

@@ -0,0 +1,83 @@
+# A2A-MetaTrace datasheet
+
+A labeled, metadata-only corpus of agent-to-agent (A2A) workflow traces, captured
+from official A2A sample agents composed into multi-agent workflows. Released as a
+standalone artifact alongside the paper; this datasheet follows the Gebru et al.
+"Datasheets for Datasets" structure.
+
+## Motivation
+The corpus evaluates metadata leakage on workloads that are not the authors' own
+generator: the protocol path (Agent Cards,
+discovery, `message/send`, SSE) and the agents are *officially authored*; only the
+workflow composition and the class labels are ours.
+
+## Composition
+- **Instances.** One trace = one workflow execution. The corpus is **270
+  traces**: 30 runs each of **9 workflow classes** over **6 capabilities**, each class
+  realized by 3 compositional **variants** (see `corpus/classes.py`), runs split across a
+  class's variants.
+- **Per message (obs(m)).** `(src, dst, t, length, direction)` plus ground truth:
+  `stage_idx`, `step_type`, `capability`, `task_class`, `n_stages`, and a `variant` tag
+  for the leave-variant-out split. **Payloads are discarded**: the corpus is metadata
+  only (the capture records lengths, not bodies), so it is exactly a passive TLS
+  observer's view and carries no message content.
+- **Labels.** `task_class` is the workflow class (the ground-truth the adversary
+  recovers); `variant` is the specific composition (the generalization group). Labels
+  and composition are ours; the protocol path is the real `a2a-sdk`.
+
+## Collection process
+Each capability is an official `a2a-samples` agent launched as a standalone A2A server in
+its own env (`corpus/sample_agents.py`, `corpus/launcher.py`); an orchestrator composes
+them per (class, variant) and a real stage runner (`corpus/runner_samples.py`) records
+obs(m) via a real discovery round-trip + `message/send` + SSE streaming, the same A2A
+wire the measured binding observes. The runner overrides each resolved Agent Card's
+interface URL to the real launch port (some samples ship a stale hardcoded card URL).
+Transport: HTTPS-direct (the protection ladder is applied analytically in the
+accompanying analysis).
+
+## Honest disclosures / limitations
+- **Provenance.** The corpus is captured from **official `a2a-samples` agents**,
+  each run unmodified as its own server: `travel_planner` (OpenAI), `adk_currency_agent`,
+  `content_planner`, `adk_skills_agent` (Gemini via Vertex), `adk_expense_reimbursement`
+  (LiteLLM→OpenAI), and `helloworld` (no-LLM echo). The protocol path (Agent Cards,
+  discovery, `message/send`, SSE streaming) and the agent logic are official; **only the
+  workflow composition and the class labels are ours.**
+- **Model substitutions (disclosed; agent logic unchanged).** Three bindings differ from
+  the samples' shipped defaults, with no behavioral edits:
+  - `adk_currency_agent`, `adk_skills_agent`: `model=` changed `gemini-3-flash-preview`
+    → `gemini-2.5-flash`.
+  - `adk_expense_reimbursement`: `LITELLM_MODEL=openai/gpt-4o-mini` (env only).
+  - `a2a_telemetry` is **excluded**: the sample hardcodes an ADK `google_search` tool with
+    a LiteLLM model, which the current ADK rejects as-shipped. These edits are not committed
+    into the `a2a-samples` clone; they are recorded here for reproducibility.
+- **Observation model.** Records are per A2A application event. Because a network observer
+  sees TLS-record bursts, not application deltas, the accompanying analysis also reports a
+  **wire-faithful** view that aggregates each stage's streamed response into one
+  observation; recovery is robust to this (see below).
+- **Uniformity.** The sample agents are more uniform than a production deployment; a
+  generalization limit, reported as such (leave-variant-out below).
+
+## Recommended splits
+Random k-fold; **leave-variant-out** (generalization: hold out whole compositions, by
+grouping on `variant` so no composition spans the train/test boundary). Report both.
+
+## Known result: real, artifact-robust, composition-specific, mitigable
+On this corpus (270 traces, 9 classes, chance 0.111, 8 seeds; reproduced by the
+accompanying analysis):
+- **Random k-fold = 0.668 ± 0.02 (6.0× chance)**; **leave-variant-out = 0.18 (~chance)**.
+  The label-blind adversary recognizes *specific, previously seen compositions*, not the
+  abstract task intent, so a held-out composition of a known class is not recovered.
+- **Not a streaming artifact.** Recovery is unchanged under the wire-faithful aggregation
+  (per-delta 0.676 → aggregated 0.668; mean msgs/wf 376 → 11), so it rests on real workflow
+  *structure*, not on the chattiest agent's per-delta volume.
+- **Mitigable.** Under a metadata-protecting transport (wire-faithful, adversary vocabulary
+  fixed from the undefended deployment): none 6.0× → metadata-min shim 4.2× → cover 0.26×
+  → cover+unlinkability **1.00× = exactly chance**.
+
+The corpus thus confirms the leakage claim on real official-SDK agent traffic, scopes it
+(recurring/profiled workflows, not zero-shot novel compositions), and shows the defense
+closes it.
+
+## Distribution
+Dataset (Parquet) + this datasheet + the capture/generation harness (`corpus/`). Load
+with `datasets` / `pandas` (see `README.md`).

LICENSE

@@ -0,0 +1,21 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright (c) 2026 Bijaya Dangol
+
+The A2A-MetaTrace corpus in this repository (the data files under `data/`, the
+datasheet, and the accompanying capture/generation harness under `corpus/` and
+`scripts/`) is licensed under the Creative Commons Attribution 4.0 International
+License (CC BY 4.0).
+
+You are free to share and adapt the material for any purpose, even commercially,
+provided you give appropriate credit, link to the license, and indicate if changes
+were made.
+
+  Full legal text: https://creativecommons.org/licenses/by/4.0/legalcode
+  Summary:         https://creativecommons.org/licenses/by/4.0/
+
+Provenance and scope: the corpus is captured from official `a2a-samples` agents.
+Those agents' code and the A2A protocol path remain under their respective upstream
+licenses; this license covers only the workflow compositions, class labels, and the
+recorded metadata (obs(m)) produced in this repository. No message payloads or
+content are included in the dataset.

README.md

@@ -0,0 +1,149 @@
+---
+license: cc-by-4.0
+pretty_name: A2A-MetaTrace
+task_categories:
+- tabular-classification
+tags:
+- traffic-analysis
+- metadata-privacy
+- agent
+- a2a
+- multi-agent
+- workflow-fingerprinting
+size_categories:
+- 100K<n<1M
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/default/train.parquet
+dataset_info:
+- config_name: default
+  features:
+  - name: trace_id
+    dtype: int64
+  - name: task_class
+    dtype: string
+  - name: variant
+    dtype: string
+  - name: client_id
+    dtype: string
+  - name: n_stages
+    dtype: int32
+  - name: stage_idx
+    dtype: int32
+  - name: step_type
+    dtype: string
+  - name: direction
+    dtype: string
+  - name: src
+    dtype: string
+  - name: dst
+    dtype: string
+  - name: t
+    dtype: float64
+  - name: length
+    dtype: int64
+  - name: capability
+    dtype: string
+  - name: label_visible
+    dtype: bool
+  - name: mode
+    dtype: string
+  - name: transport
+    dtype: string
+  splits:
+  - name: train
+    num_examples: 101516
+---
+
+# A2A-MetaTrace
+
+A labeled, **metadata-only** corpus of multi-agent **A2A** (Agent-to-Agent) workflow
+traffic. Each row is one wire message reduced to what a passive network observer sees,
+`obs(m) = (src, dst, t, length, direction)`, with workflow ground-truth labels; message
+bodies are discarded. The corpus exists to study how much of a *pending agent workflow*
+leaks from communication-graph metadata alone, and to evaluate metadata-protecting
+transports against it.
+
+**Links:** [GitHub](https://github.com/dangoldbj/a2a-metatrace) | [HuggingFace dataset](https://huggingface.co/datasets/dangoldbj/a2a-metatrace) | [Paper (arXiv)](https://arxiv.org/abs/2606.07150)
+
+**Provenance (disclosed).** Workflows run over the real `a2a-sdk` protocol path
+(Agent Cards, discovery, `message/send`, SSE) against real official `a2a-samples` agent
+servers backed by real language-model calls. The workflow *compositions* and *labels*
+are ours (see `DATASHEET.md`). This is the honest provenance claim: the protocol path and
+agent behavior are real; the composition is designed.
+
+## Config
+
+| config | agent backend | transport | workflows | classes | variants | rows (messages) |
+|---|---|---|---|---|---|---|
+| `default` | agents | https | 270 | 9 | 27 | 101516 |
+
+The corpus is captured from official `a2a-samples` agents composed into multi-agent
+workflows; transport is HTTPS-direct (the metadata-protecting transport is evaluated
+analytically; see `DATASHEET.md`).
+
+## Usage
+
+```python
+from datasets import load_dataset
+import pandas as pd
+
+ds = load_dataset("a2a-metatrace", split="train")   # message-level rows
+df = ds.to_pandas()
+
+# reconstruct workflows and their labels by grouping on trace_id
+by_wf = df.groupby("trace_id")
+labels = by_wf["task_class"].first()
+```
+
+A workflow is the unit an adversary classifies; featurize per `trace_id` (message counts,
+length stats, timing, direction n-grams) and recover `task_class`. Use the `variant`
+column for a **leave-variant-out** split (generalization to unseen compositions).
+
+## Regenerating the corpus
+
+The published Parquet is produced by capturing real official `a2a-samples` agents. To
+reproduce it end to end:
+
+1. **Get the agents.** Clone the official samples repo and point the harness at its
+   Python agents directory:
+   ```bash
+   git clone https://github.com/a2aproject/a2a-samples.git
+   export A2A_SAMPLES_DIR=$(pwd)/a2a-samples/samples/python/agents
+   ```
+2. **Provide model credentials.** The sample agents call real models:
+   - `export OPENAI_API_KEY=...` (the OpenAI- and LiteLLM-backed agents), and
+   - for the Google-ADK agents, a Vertex project via Application Default Credentials:
+     `export GOOGLE_CLOUD_PROJECT=...` and `gcloud auth application-default login`.
+
+   Keys may instead be placed in a local `.envrc` (`export KEY=VALUE` lines); see
+   `corpus/sample_agents.py` for all configuration variables.
+3. **Install and run** (Python 3.13):
+   ```bash
+   uv sync
+   uv run python -m corpus.run_corpus --runs-per-class 30   # writes results/corpus/a2a_metatrace.json
+   uv run python scripts/export_hf.py                        # writes data/ + this README
+   ```
+
+See `DATASHEET.md` for the workflow classes, provenance, and disclosed model substitutions.
+
+## What it is for
+
+- **Workflow-fingerprinting / traffic analysis** on agent interoperation traffic.
+- **Evaluating metadata-protecting transports** for agent interoperation.
+- A reproducible, provenance-disclosed alternative to purely synthetic agent-traffic models.
+
+See `DATASHEET.md` for construction, intended use, and limitations. Regenerate this card
+and the Parquet files with `uv run python scripts/export_hf.py`.
+
+## Citation
+
+```bibtex
+@misc{a2ametatrace,
+  title  = {A2A-MetaTrace: a metadata-only corpus of multi-agent A2A workflow traffic},
+  author = {Dangol, Bijaya},
+  year   = {2026}
+}
+```

corpus/classes.py

@@ -0,0 +1,114 @@
+r"""A2A-MetaTrace workflow classes and their compositional variants.
+
+A *class* is the ground-truth label the adversary recovers; a *variant* is one concrete
+capability composition that realizes it. Every variant of a class shares a distinctive
+ordered **motif** (a characteristic capability pair) and differs in the *filler*
+capabilities around it. The motif is the class invariant a leave-variant-out adversary
+can latch onto; the filler, drawn from a vocabulary shared across classes, is what makes
+a held-out variant a genuinely novel composition. So leave-variant-out asks the honest
+generalization question, "does leakage survive compositions the adversary never saw?",
+rather than collapsing to "can it recover a class with no shared structure?".
+
+The orchestrator executes a (class, variant) as a real multi-agent A2A workflow, one
+stage per capability. Provenance discipline (disclosed in the datasheet): the protocol
+path is the real ``a2a-sdk`` and the agents run real streaming workflows; the
+composition and labels are ours.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class WorkflowClassTemplate:
+    """One variant: an ordered capability composition with a unique name."""
+
+    name: str
+    stages: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class TaskClass:
+    """A label realized by several variants that share a capability motif."""
+
+    name: str
+    variants: tuple[WorkflowClassTemplate, ...]
+
+
+# Capabilities are served by REAL official a2a-samples agents (corpus.sample_agents):
+#   travel (OpenAI), currency/expense/content (Gemini-ADK via Vertex), echo (no-LLM filler).
+# Each class is anchored by a distinct ordered motif (present in all its variants) and
+# padded with shared filler so compositions overlap across classes without erasing the
+# per-class invariant -- the structure the leave-variant-out split tests.
+CLASSES: tuple[TaskClass, ...] = (
+    TaskClass("fx_quote", (                    # motif: travel -> currency
+        WorkflowClassTemplate("fx_quote_bare", ("travel", "currency")),
+        WorkflowClassTemplate("fx_quote_doc", ("travel", "currency", "content")),
+        WorkflowClassTemplate("fx_quote_pre", ("echo", "travel", "currency")),
+    )),
+    TaskClass("trip_brief", (                   # motif: travel -> content
+        WorkflowClassTemplate("trip_brief_bare", ("travel", "content")),
+        WorkflowClassTemplate("trip_brief_fx", ("travel", "content", "currency")),
+        WorkflowClassTemplate("trip_brief_pre", ("echo", "travel", "content")),
+    )),
+    TaskClass("content_trip", (                 # motif: content -> travel
+        WorkflowClassTemplate("content_trip_bare", ("content", "travel")),
+        WorkflowClassTemplate("content_trip_fx", ("content", "travel", "currency")),
+        WorkflowClassTemplate("content_trip_pre", ("echo", "content", "travel")),
+    )),
+    TaskClass("fx_content", (                   # motif: currency -> content
+        WorkflowClassTemplate("fx_content_bare", ("currency", "content")),
+        WorkflowClassTemplate("fx_content_trip", ("currency", "content", "travel")),
+        WorkflowClassTemplate("fx_content_pre", ("echo", "currency", "content")),
+    )),
+    TaskClass("doc_fx", (                       # motif: content -> currency
+        WorkflowClassTemplate("doc_fx_bare", ("content", "currency")),
+        WorkflowClassTemplate("doc_fx_trip", ("content", "currency", "travel")),
+        WorkflowClassTemplate("doc_fx_pre", ("echo", "content", "currency")),
+    )),
+    TaskClass("reimburse", (                    # motif: currency -> expense  (finance)
+        WorkflowClassTemplate("reimburse_bare", ("currency", "expense")),
+        WorkflowClassTemplate("reimburse_doc", ("currency", "expense", "content")),
+        WorkflowClassTemplate("reimburse_pre", ("travel", "currency", "expense")),
+    )),
+    TaskClass("expense_brief", (                # motif: expense -> content  (finance)
+        WorkflowClassTemplate("expense_brief_bare", ("expense", "content")),
+        WorkflowClassTemplate("expense_brief_fx", ("expense", "content", "currency")),
+        WorkflowClassTemplate("expense_brief_pre", ("travel", "expense", "content")),
+    )),
+    TaskClass("skill_brief", (                  # motif: skills -> content
+        WorkflowClassTemplate("skill_brief_bare", ("skills", "content")),
+        WorkflowClassTemplate("skill_brief_fx", ("skills", "content", "currency")),
+        WorkflowClassTemplate("skill_brief_pre", ("echo", "skills", "content")),
+    )),
+    TaskClass("skill_fx", (                     # motif: skills -> currency
+        WorkflowClassTemplate("skill_fx_bare", ("skills", "currency")),
+        WorkflowClassTemplate("skill_fx_doc", ("skills", "currency", "content")),
+        WorkflowClassTemplate("skill_fx_pre", ("echo", "skills", "currency")),
+    )),
+)
+
+
+def all_variants() -> list[tuple[str, WorkflowClassTemplate]]:
+    """Flatten to (class_label, variant) pairs."""
+    return [(c.name, v) for c in CLASSES for v in c.variants]
+
+
+def capabilities() -> list[str]:
+    """The distinct capabilities any variant invokes (one agent server each)."""
+    caps: list[str] = []
+    for c in CLASSES:
+        for v in c.variants:
+            for cap in v.stages:
+                if cap not in caps:
+                    caps.append(cap)
+    return caps
+
+
+def class_of(variant_name: str) -> str:
+    for c in CLASSES:
+        for v in c.variants:
+            if v.name == variant_name:
+                return c.name
+    raise KeyError(variant_name)

corpus/launcher.py

@@ -0,0 +1,97 @@
+"""Launch the official sample agents as subprocesses and health-check them.
+
+Each agent runs in its own directory/env (its own ``uv.lock``, Python 3.13). We start it
+with ``subprocess.Popen``, wait until its Agent Card endpoint answers, and return the
+capabilities that came up. Agents that fail to start within the timeout are skipped (and
+reported), so one flaky sample does not block the whole corpus run.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass, field
+
+import httpx
+
+from corpus.sample_agents import AGENTS, AgentSpec
+
+
+def _free_port(port: int) -> None:
+    """Kill any stale process holding ``port`` (orphaned agent from a killed run)."""
+    try:
+        out = subprocess.run(["lsof", "-ti", f"tcp:{port}"], capture_output=True, text=True)
+        for pid in out.stdout.split():
+            subprocess.run(["kill", "-9", pid], capture_output=True)
+    except Exception:
+        pass
+
+
+@dataclass
+class LiveAgents:
+    urls: dict[str, str] = field(default_factory=dict)        # capability -> base url
+    tokens: dict[str, str] = field(default_factory=dict)      # capability -> provider token
+    domains: dict[str, str] = field(default_factory=dict)     # capability -> domain
+    _procs: list[subprocess.Popen] = field(default_factory=list)
+    _logs: list = field(default_factory=list)
+
+    def stop(self) -> None:
+        for p in self._procs:
+            p.terminate()
+        time.sleep(1.0)
+        for p in self._procs:
+            if p.poll() is None:
+                p.kill()
+        for f in self._logs:
+            try:
+                f.close()
+            except Exception:
+                pass
+
+
+def _card_ok(url: str) -> bool:
+    try:
+        return httpx.get(f"{url}/.well-known/agent-card.json", timeout=1.5).status_code == 200
+    except httpx.HTTPError:
+        return False
+
+
+def launch(specs: tuple[AgentSpec, ...] = AGENTS, *, startup_timeout: float = 240.0) -> LiveAgents:
+    """Start every spec; return the ones whose card endpoint comes up."""
+    live = LiveAgents()
+    pending: list[tuple[AgentSpec, subprocess.Popen]] = []
+    for spec in specs:
+        _free_port(spec.port)  # clear any orphaned agent holding this port
+        log = open(f"/tmp/a2a_metatrace_{spec.capability}.log", "w")
+        live._logs.append(log)
+        proc = subprocess.Popen(
+            spec.argv(), cwd=str(spec.cwd), env=spec.env(),
+            stdout=log, stderr=subprocess.STDOUT,
+        )
+        live._procs.append(proc)
+        pending.append((spec, proc))
+        print(f"[launch] {spec.capability:9s} pid={proc.pid} :{spec.port} ({spec.auth}) {spec.subdir}")
+
+    deadline = time.time() + startup_timeout
+    up: set[str] = set()
+    while time.time() < deadline and len(up) < len(pending):
+        for spec, proc in pending:
+            if spec.capability in up:
+                continue
+            if proc.poll() is not None:  # process died
+                continue
+            if _card_ok(spec.url):
+                up.add(spec.capability)
+                live.urls[spec.capability] = spec.url
+                live.tokens[spec.capability] = spec.provider_token
+                live.domains[spec.capability] = spec.domain
+                print(f"[ready]  {spec.capability:9s} {spec.url}")
+        time.sleep(2.0)
+
+    for spec, proc in pending:
+        if spec.capability not in up:
+            dead = proc.poll() is not None
+            print(f"[SKIP]   {spec.capability:9s} did not come up "
+                  f"({'process exited' if dead else 'timeout'}; see /tmp/a2a_metatrace_{spec.capability}.log)")
+    print(f"[launch] {len(up)}/{len(pending)} agents live: {sorted(up)}")
+    return live

corpus/orchestrator.py

@@ -0,0 +1,108 @@
+"""A2A-MetaTrace orchestrator: compose sample agents into labeled workflows.
+
+The orchestrator turns a :class:`~corpus.classes.WorkflowClassTemplate` into a real
+multi-agent A2A workflow and records metadata-only message dicts in a fixed 13-field
+schema, so the exported corpus loads unchanged. It is deliberately decoupled from how a
+stage is executed: a ``stage_runner`` callable performs one stage and returns its
+records. The real runner (``corpus.runner_samples``, driven by ``corpus.run_corpus``)
+drives official sample-agent servers over the ``a2a-sdk`` via a real discovery round-trip
++ ``message/send`` + SSE streaming; the offline test injects a scripted runner, so the
+composition and record schema are covered without standing up servers.
+
+The record schema:
+    trace_id, task_class, client_id, n_stages, stage_idx, step_type, capability,
+    label_visible, src, dst, t, length, direction
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from corpus.classes import CLASSES, TaskClass, WorkflowClassTemplate
+
+# stage_runner(variant, instance, stage_idx, capability, client_id) -> list[record]
+StageRunner = Callable[[WorkflowClassTemplate, int, int, str, str], list[dict]]
+
+# The 13 fields a stage runner must supply per message; the orchestrator adds the
+# workflow-level labels (trace_id, task_class, client_id, n_stages, stage_idx,
+# capability) and a `variant` tag for the leave-variant-out split, which is extra
+# (records_to_traces ignores unknown keys).
+REQUIRED_FIELDS = frozenset(
+    {
+        "trace_id", "task_class", "client_id", "n_stages", "stage_idx", "step_type",
+        "capability", "label_visible", "src", "dst", "t", "length", "direction",
+    }
+)
+
+
+def run_workflow(
+    variant: WorkflowClassTemplate,
+    instance: int,
+    *,
+    task_class: str,
+    trace_id: int,
+    client_id: str,
+    stage_runner: StageRunner,
+) -> list[dict]:
+    """Execute one workflow instance of ``variant`` under label ``task_class``.
+
+    Each record carries the workflow-level ground truth (``trace_id``, the class
+    ``task_class``, the ``variant`` name for grouped evaluation, ``client_id``, stage
+    count) so the corpus is self-describing; individual runners emit only the
+    per-message obs(m) + stage/step labels.
+    """
+    n_stages = len(variant.stages)
+    records: list[dict] = []
+    for stage_idx, capability in enumerate(variant.stages):
+        for rec in stage_runner(variant, instance, stage_idx, capability, client_id):
+            rec = {
+                "trace_id": trace_id,
+                "task_class": task_class,
+                "variant": variant.name,
+                "client_id": client_id,
+                "n_stages": n_stages,
+                "stage_idx": stage_idx,
+                "capability": capability,
+                **rec,
+            }
+            missing = REQUIRED_FIELDS - rec.keys()
+            if missing:
+                raise ValueError(f"stage runner record missing fields: {sorted(missing)}")
+            records.append(rec)
+    return records
+
+
+def run_corpus(
+    classes: tuple[TaskClass, ...] = CLASSES,
+    *,
+    runs_per_class: int,
+    stage_runner: StageRunner,
+    transport: str = "https-direct",
+    proxy: str | None = None,
+    client_ids: tuple[str, ...] = ("client-001", "client-002", "client-003"),
+) -> dict:
+    """Build the capture document: ~``runs_per_class`` instances per class, split
+    across that class's variants as evenly as possible.
+
+    The ``trace_id`` is a global counter; clients round-robin across the pool so the
+    corpus has the same persistent-client structure as the synthetic population (the
+    unlinkability target). Returns the ``{transport, proxy, messages:[...]}`` document
+    ``records_to_traces`` consumes; the ``variant`` tag rides along for grouped eval.
+    """
+    messages: list[dict] = []
+    trace_id = 0
+    for cls in classes:
+        nvar = len(cls.variants)
+        for vi, variant in enumerate(cls.variants):
+            # distribute runs_per_class across variants (front variants absorb the
+            # remainder), so class totals stay balanced regardless of variant count
+            runs = runs_per_class // nvar + (1 if vi < runs_per_class % nvar else 0)
+            for instance in range(runs):
+                client_id = client_ids[trace_id % len(client_ids)]
+                messages.extend(
+                    run_workflow(variant, instance, task_class=cls.name,
+                                 trace_id=trace_id, client_id=client_id,
+                                 stage_runner=stage_runner)
+                )
+                trace_id += 1
+    return {"transport": transport, "proxy": proxy, "messages": messages}

corpus/probe_enrichment.py

@@ -0,0 +1,38 @@
+"""Smoke-test for live sample-agent routing (Agent Card URL override + streaming).
+
+Launches a small set of capabilities and runs one stage each, so routing failures
+surface before any full corpus run. Not part of the corpus pipeline itself."""
+
+from __future__ import annotations
+
+from corpus.launcher import launch
+from corpus.runner_samples import build_sample_stage_runner
+from corpus.sample_agents import BY_CAPABILITY
+
+CAPS = ("currency", "content", "skills")
+
+
+def main() -> None:
+    specs = tuple(BY_CAPABILITY[c] for c in CAPS)
+    live = launch(specs)
+    runner, teardown = build_sample_stage_runner(live)
+    try:
+        for cap in CAPS:
+            if cap not in live.urls:
+                print(f"  {cap:9s} -> NOT LIVE (skipped launch)")
+                continue
+            try:
+                recs = runner(f"{cap}_probe", 0, 0, cap, "client-0")
+                msgs = len(recs)
+                final = next((r for r in recs if r.get("step_type") == "response"), None)
+                size = final["length"] if final else 0
+                print(f"  {cap:9s} -> OK  ({msgs} records, final={size}B)")
+            except Exception as e:  # noqa: BLE001
+                print(f"  {cap:9s} -> FAIL {type(e).__name__}: {e}")
+    finally:
+        teardown()
+        live.stop()
+
+
+if __name__ == "__main__":
+    main()

corpus/run_corpus.py

@@ -0,0 +1,99 @@
+"""Generate the A2A-MetaTrace corpus from real official a2a-samples agents.
+
+Launches the official sample agents (each in its own env), drives every workflow class
+through its variants over the real ``a2a-sdk`` wire, records obs(m), and writes the
+``{transport, messages}`` capture document ``scripts/export_hf.py`` consumes.
+
+    uv run python -m corpus.run_corpus --runs-per-class 12
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+from corpus.classes import CLASSES
+from corpus.launcher import launch
+from corpus.orchestrator import run_workflow
+from corpus.runner_samples import build_sample_stage_runner
+
+CLIENT_IDS = ("client-001", "client-002", "client-003")
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _filter_classes(live_caps: set[str]):
+    """Keep only classes whose every variant uses only live capabilities."""
+    kept = []
+    for cls in CLASSES:
+        ok = all(all(c in live_caps for c in v.stages) for v in cls.variants)
+        if ok:
+            kept.append(cls)
+        else:
+            missing = {c for v in cls.variants for c in v.stages if c not in live_caps}
+            print(f"[skip class] {cls.name}: needs missing caps {sorted(missing)}")
+    return tuple(kept)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--runs-per-class", type=int, default=12)
+    ap.add_argument("--out", type=Path,
+                    default=ROOT / "results" / "corpus" / "a2a_metatrace.json")
+    args = ap.parse_args()
+
+    live = launch()
+    if len(live.urls) < 2:
+        print("fewer than 2 agents live; aborting")
+        live.stop()
+        return
+    classes = _filter_classes(set(live.urls))
+    if not classes:
+        print("no class fully covered by live agents; aborting")
+        live.stop()
+        return
+
+    stage_runner, teardown = build_sample_stage_runner(live)
+    t0 = time.time()
+    messages: list[dict] = []
+    trace_id = skipped = 0
+    try:
+        total = args.runs_per_class * len(classes)
+        print(f"generating ~{total} workflows over {len(classes)} classes "
+              f"({[c.name for c in classes]}), {args.runs_per_class}/class ...")
+        for cls in classes:
+            nvar = len(cls.variants)
+            for vi, variant in enumerate(cls.variants):
+                runs = args.runs_per_class // nvar + (1 if vi < args.runs_per_class % nvar else 0)
+                for instance in range(runs):
+                    client_id = CLIENT_IDS[trace_id % len(CLIENT_IDS)]
+                    # a whole workflow is the retry unit: a failed stage drops only its
+                    # workflow (partial records discarded), never the whole corpus.
+                    try:
+                        recs = run_workflow(variant, instance, task_class=cls.name,
+                                            trace_id=trace_id, client_id=client_id,
+                                            stage_runner=stage_runner)
+                        messages.extend(recs)
+                    except Exception as e:  # noqa: BLE001
+                        skipped += 1
+                        print(f"  ! skip wf {trace_id} ({variant.name}): {type(e).__name__}: {str(e)[:80]}")
+                    trace_id += 1
+                    if trace_id % 20 == 0:
+                        print(f"  ... {trace_id} workflows, {len(messages)} msgs, {skipped} skipped")
+    finally:
+        teardown()
+        live.stop()
+    wall = time.time() - t0
+
+    capture = {"transport": "https-direct", "proxy": None, "messages": messages}
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(json.dumps(capture))
+    n_wf = len({m["trace_id"] for m in capture["messages"]})
+    print(f"wrote {len(messages)} messages ({n_wf} workflows, {skipped} skipped) "
+          f"in {wall:.0f}s -> {args.out}")
+
+
+if __name__ == "__main__":
+    main()

corpus/runner_samples.py

@@ -0,0 +1,148 @@
+"""Stage runner that drives the live official sample agents and records obs(m).
+
+Returns a ``stage_runner(variant, instance, stage_idx, capability, client_id)`` the
+orchestrator calls once per workflow stage. Each call performs, against that capability's
+real sample-agent server:
+
+* a real **discovery** round-trip (Agent Card fetch); the capability is named here, the
+  semantic-label channel (``label_visible=True``), and
+* a real **message/send** + streamed updates/final response, recorded as wire-only
+  obs(m): request byte size (httpx request hook), per-event serialized sizes, timestamps,
+  and an *opaque* provider token (not the capability name).
+
+The orchestrator is synchronous and a2a-sdk is async, so we own a background event loop:
+clients live in it and each synchronous stage call submits its coroutine and blocks for
+the records. The 7 per-message fields here + the orchestrator's workflow labels make the
+13-field obs(m) record the dataset exports.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+import time
+import uuid
+from collections.abc import Callable
+
+import httpx
+from a2a.client.card_resolver import A2ACardResolver
+from a2a.client.client_factory import ClientConfig, ClientFactory
+from a2a.types import Message, Part, Role, SendMessageConfiguration, SendMessageRequest
+
+# Capability-appropriate user prompts so the real agents do real work (content-driven sizes).
+PROMPTS: dict[str, str] = {
+    "travel": "Plan a 3-day trip to Lisbon with a rough daily schedule.",
+    "currency": "How much is 250 USD in EUR right now?",
+    "expense": "I need to file a reimbursement for a 320 USD client dinner in Berlin.",
+    "content": "Draft a short outline for a blog post about sustainable travel.",
+    "echo": "hello there",
+    "skills": "What skills and capabilities are relevant for organizing a business trip?",
+}
+_DEFAULT_PROMPT = "Please handle this request."
+
+# Capabilities whose sample server runs an a2a-sdk too old to advertise the streaming
+# method our client would pick from a streaming-capable card; force them onto the
+# universally-supported message/send path.
+_NON_STREAMING: set[str] = set()
+
+
+def build_sample_stage_runner(live) -> tuple[Callable, Callable[[], None]]:
+    """Given launched agents (``LiveAgents``), return ``(stage_runner, teardown)``."""
+    urls = live.urls
+    tokens = live.tokens
+
+    loop = asyncio.new_event_loop()
+    threading.Thread(target=loop.run_forever, daemon=True).start()
+
+    def _submit(coro):
+        return asyncio.run_coroutine_threadsafe(coro, loop).result()
+
+    clients: dict[str, dict] = {}
+    state: dict = {"pending": None}
+
+    async def _on_request(request: httpx.Request) -> None:
+        # record the c2s message/send body size at send time
+        if request.method == "POST" and state["pending"] is not None:
+            state["pending"]["length"] = len(request.content or b"")
+            state["pending"]["t"] = time.perf_counter()
+
+    async def _setup() -> None:
+        for cap, url in urls.items():
+            http = httpx.AsyncClient(timeout=120, event_hooks={"request": [_on_request]})
+            card = await A2ACardResolver(http, url + "/").get_agent_card()
+            # Some sample agents ship a static/copied agent_card.json with a stale hardcoded
+            # interface URL (adk_skills_agent advertises localhost:10999, ignoring --port), so
+            # the factory would dial the wrong server. We launched each agent ourselves and
+            # know its real URL -- force every advertised interface onto it.
+            for iface in card.supported_interfaces:
+                iface.url = url
+            streaming = cap not in _NON_STREAMING
+            client = ClientFactory(ClientConfig(httpx_client=http, streaming=streaming)).create(card)
+            clients[cap] = {"client": client, "http": http, "card_http": httpx.AsyncClient(timeout=30)}
+
+    _submit(_setup())
+
+    async def _run_stage(capability, client_id) -> list[dict]:
+        url = urls[capability]
+        provider = tokens[capability]
+        buf: list[dict] = []
+
+        # --- discovery: real Agent Card fetch (names the capability => label channel) ---
+        t_q = time.perf_counter()
+        card_http = clients[capability]["card_http"]
+        req_path = "/.well-known/agent-card.json"
+        resp = await card_http.get(url + req_path)
+        buf.append({"step_type": "discovery_query", "direction": "c2s",
+                    "src": client_id, "dst": "registry", "t": t_q,
+                    "length": len(req_path.encode()) + 64, "label_visible": True})
+        buf.append({"step_type": "discovery_result", "direction": "s2c",
+                    "src": "registry", "dst": client_id, "t": time.perf_counter(),
+                    "length": len(resp.content), "label_visible": False})
+
+        # --- delegation: real message/send + streamed updates/response ---
+        text = PROMPTS.get(capability, _DEFAULT_PROMPT)
+        msg = Message(message_id=str(uuid.uuid4()), role=Role.ROLE_USER, parts=[Part(text=text)])
+        req = SendMessageRequest(
+            message=msg,
+            configuration=SendMessageConfiguration(accepted_output_modes=["text/plain"]),
+        )
+        state["pending"] = {"length": 0, "t": time.perf_counter()}
+        stream: list[dict] = []
+        async for ev in clients[capability]["client"].send_message(req):
+            stream.append({"direction": "s2c", "src": provider, "dst": client_id,
+                           "t": time.perf_counter(),
+                           "length": len(ev.SerializeToString()), "label_visible": False})
+        pend = state["pending"]
+        state["pending"] = None
+        buf.append({"step_type": "request", "direction": "c2s", "src": client_id,
+                    "dst": provider, "t": pend["t"], "length": pend["length"],
+                    "label_visible": False})
+        for k, rec in enumerate(stream):
+            rec["step_type"] = "response" if k == len(stream) - 1 else "update"
+        buf.extend(stream)
+        return buf
+
+    def stage_runner(variant, instance, stage_idx, capability, client_id) -> list[dict]:
+        # real agents drop streams transiently (and free-tier Gemini rate-limits), so retry
+        # a stage with rate-limit-aware backoff before the whole workflow is abandoned (the
+        # orchestrator turns a raised error into a skip).
+        last: Exception | None = None
+        for wait in (4, 15, 40):
+            try:
+                return _submit(_run_stage(capability, client_id))
+            except Exception as e:  # noqa: BLE001 - any transport/agent/rate-limit hiccup
+                last = e
+                time.sleep(wait)
+        raise last  # type: ignore[misc]
+
+    def teardown() -> None:
+        async def _close():
+            for c in clients.values():
+                await c["http"].aclose()
+                await c["card_http"].aclose()
+        try:
+            _submit(_close())
+        finally:
+            loop.call_soon_threadsafe(loop.stop)
+
+    return stage_runner, teardown

corpus/sample_agents.py

@@ -0,0 +1,128 @@
+"""Registry of the official ``a2a-samples`` agents the corpus drives.
+
+Each capability is served by a *real* official sample agent run as its own process in
+its own env (its `uv.lock`), pinned to Python 3.13 (newer alpha interpreters break some
+native builds). The orchestrator connects as an a2a-sdk client and records obs(m); the
+agents bring their own LLM calls (OpenAI or Gemini-via-Vertex). Provenance disclosed in
+``DATASHEET.md``: the protocol path and the agents are official; only the composition is ours.
+
+Configuration (all via environment):
+* ``A2A_SAMPLES_DIR``: path to the official ``a2a-samples`` checkout's
+  ``samples/python/agents`` directory. Defaults to a sibling ``a2a-samples`` checkout.
+* ``openai`` agents read ``OPENAI_API_KEY`` (travel_planner reads it as ``API_KEY``).
+* ``vertex`` (ADK) agents use ``GOOGLE_CLOUD_PROJECT`` / ``GOOGLE_CLOUD_LOCATION`` with
+  ``GOOGLE_GENAI_USE_VERTEXAI=true``; a placeholder ``GOOGLE_API_KEY`` satisfies the
+  samples' startup guard while the call routes through Vertex/ADC.
+
+Keys may also be supplied via an ``.envrc`` file (``export KEY=VALUE`` lines); set its
+path with ``A2A_METATRACE_ENVRC`` (defaults to ``.envrc`` in the working directory).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+HOST = "127.0.0.1"
+SAMPLES_DIR = Path(
+    os.environ.get(
+        "A2A_SAMPLES_DIR",
+        Path(__file__).resolve().parent.parent.parent
+        / "a2a-samples"
+        / "samples"
+        / "python"
+        / "agents",
+    )
+)
+ENVRC = Path(os.environ.get("A2A_METATRACE_ENVRC", ".envrc"))
+
+GCLOUD_PROJECT = os.environ.get("GOOGLE_CLOUD_PROJECT", "")
+GCLOUD_LOCATION = os.environ.get("GOOGLE_CLOUD_LOCATION", "us-central1")
+
+
+def _env_or_envrc(var: str) -> str:
+    """Read ``var`` from the environment, falling back to the optional ``.envrc``."""
+    if os.environ.get(var):
+        return os.environ[var]
+    if ENVRC.exists():
+        for line in ENVRC.read_text().splitlines():
+            line = line.strip()
+            if line.startswith(f"export {var}="):
+                return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise RuntimeError(f"{var} not found in env or {ENVRC}")
+
+
+def _openai_key() -> str:
+    """Read OPENAI_API_KEY from the environment or the optional .envrc."""
+    return _env_or_envrc("OPENAI_API_KEY")
+
+
+def _vertex_env() -> dict[str, str]:
+    return {
+        "GOOGLE_GENAI_USE_VERTEXAI": "TRUE",  # uppercase: some samples compare exactly
+        "GOOGLE_CLOUD_PROJECT": GCLOUD_PROJECT,
+        "GOOGLE_CLOUD_LOCATION": GCLOUD_LOCATION,
+        # ADC performs the real call; these placeholders only satisfy the samples'
+        # startup guards (some check GOOGLE_API_KEY, some GEMINI_API_KEY).
+        "GOOGLE_API_KEY": "vertex-adc-in-use-placeholder",
+        "GEMINI_API_KEY": "vertex-adc-in-use-placeholder",
+    }
+
+
+@dataclass(frozen=True)
+class AgentSpec:
+    capability: str          # the corpus capability label
+    domain: str              # finance | travel | content | generic
+    subdir: str              # directory under SAMPLES_DIR
+    run_args: tuple[str, ...]  # args after `uv run --python 3.13`
+    port: int
+    auth: str                # openai | vertex | litellm_openai | none
+    provider_token: str      # opaque endpoint token on the wire (NOT the capability name)
+
+    @property
+    def cwd(self) -> Path:
+        return SAMPLES_DIR / self.subdir
+
+    @property
+    def url(self) -> str:
+        return f"http://{HOST}:{self.port}"
+
+    def env(self) -> dict[str, str]:
+        e = dict(os.environ)
+        # don't leak our orchestrator's venv into the agent's own uv project resolution
+        for k in ("VIRTUAL_ENV", "UV_PROJECT_ENVIRONMENT", "UV_PYTHON", "PYTHONPATH"):
+            e.pop(k, None)
+        if self.auth == "openai":
+            e["API_KEY"] = _openai_key()
+            e["OPENAI_API_KEY"] = _openai_key()
+        elif self.auth == "vertex":
+            e.update(_vertex_env())
+        elif self.auth == "litellm_openai":
+            # litellm-based ADK agents read the model from LITELLM_MODEL (env only, no
+            # code edit); the placeholder keys only satisfy the startup guards.
+            e.pop("GOOGLE_GENAI_USE_VERTEXAI", None)
+            e["OPENAI_API_KEY"] = _openai_key()
+            e["LITELLM_MODEL"] = "openai/gpt-4o-mini"
+            e["GEMINI_API_KEY"] = "placeholder-litellm-uses-openai"
+            e["GOOGLE_API_KEY"] = "placeholder-litellm-uses-openai"
+        return e
+
+    def argv(self) -> list[str]:
+        return ["uv", "run", "--python", "3.13", *self.run_args]
+
+
+# The chosen set: official sample agents, mixed providers, 3 domains. Ports are distinct
+# (travel_planner + helloworld hardcode theirs; ADK agents take --port).
+AGENTS: tuple[AgentSpec, ...] = (
+    AgentSpec("travel", "travel", "travel_planner_agent", (".",), 10001, "openai", "agent-0001"),
+    AgentSpec("currency", "finance", "adk_currency_agent", ("currency_agent",), 10999, "vertex", "agent-0002"),
+    # adk_expense_reimbursement is litellm-based; LITELLM_MODEL points it at OpenAI (env only).
+    AgentSpec("expense", "finance", "adk_expense_reimbursement", (".", "--port", "10002"), 10002, "litellm_openai", "agent-0003"),
+    # content_planner ships no uv.lock and uses the 0.3.x server API, so pin a2a-sdk <1.0
+    AgentSpec("content", "content", "content_planner", ("--with", "a2a-sdk[http-server]<1.0", ".", "--port", "10003"), 10003, "vertex", "agent-0004"),
+    AgentSpec("echo", "generic", "helloworld", ("python", "__main__.py"), 9999, "none", "agent-0005"),
+    AgentSpec("skills", "knowledge", "adk_skills_agent", ("skills_agent", "--port", "10004"), 10004, "vertex", "agent-0006"),
+)
+
+BY_CAPABILITY: dict[str, AgentSpec] = {a.capability: a for a in AGENTS}

data/default/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f4e3e87bd2ec4f5f4f3d2fb97f7a21e6c7f4e9862ab977f2aec9b7c4e9c51dd
+size 973617

pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "a2a-metatrace"
+version = "0.1.0"
+description = "A2A-MetaTrace: a labeled, metadata-only corpus of multi-agent A2A workflow traffic, built from real a2a-sdk agents. Generation harness + HuggingFace-style dataset export."
+readme = "README.md"
+authors = [
+    { name = "Bijaya Dangol", email = "dangoldbj23@gmail.com" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    # generation: real A2A servers + clients, optional real-LLM agents
+    "a2a-sdk>=1.1.0",
+    "httpx>=0.28.1",
+    "sse-starlette>=3.4.4",
+    "starlette>=1.2.1",
+    "uvicorn>=0.48.0",
+    "openai>=1.40.0",
+    # dataset export (HuggingFace-style Parquet)
+    "pandas>=3.0.3",
+    "pyarrow>=18.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "ruff>=0.15.15",
+    "datasets>=3.0.0",  # to verify the export loads as a HF dataset
+]
+
+[tool.uv]
+package = false  # a workspace of scripts/packages, not a distributable wheel
+
+[tool.ruff]
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]  # make the top-level `corpus` package importable in tests

scripts/export_hf.py

@@ -0,0 +1,235 @@
+"""Export the raw A2A-MetaTrace capture JSON into a HuggingFace-style dataset.
+
+Each generation run (``corpus.run_corpus``) writes a capture document
+``results/corpus/a2a_metatrace.json`` whose ``messages`` list is a flat sequence of
+metadata-only records ``obs(m)`` with workflow ground-truth labels.
+This script turns that capture into the layout the HuggingFace Hub expects:
+
+* one Parquet file per config under ``data/<config>/train.parquet`` (message-level rows,
+  the natural tabular form; reconstruct a workflow by grouping on ``trace_id``), and
+* a dataset card ``README.md`` whose YAML front matter declares the ``configs`` and
+  ``dataset_info`` so ``datasets.load_dataset("<repo>", "<config>")`` just works.
+
+Run:
+    uv run python scripts/export_hf.py
+The published artifact is ``data/*.parquet`` + ``README.md``; the raw JSON is an
+intermediate (gitignored). The prose datasheet lives in ``DATASHEET.md``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+CORPUS = ROOT / "results" / "corpus"
+DATA = ROOT / "data"
+
+# capture file -> (config name, mode, transport). A config is one coherent slice a
+# consumer would load on its own; mode/transport ride along as columns too.
+CONFIGS: list[tuple[str, str, str, str]] = [
+    # traffic from real official a2a-samples agents
+    ("a2a_metatrace.json", "default", "agents", "https"),
+]
+
+# The message-level row schema. Order is the dataset's column order; dtypes are the
+# HuggingFace feature dtypes the card advertises.
+SCHEMA: list[tuple[str, str]] = [
+    ("trace_id", "int64"),       # workflow id; group on this to reconstruct a workflow
+    ("task_class", "string"),    # the label an adversary recovers
+    ("variant", "string"),       # the concrete composition (group for leave-variant-out)
+    ("client_id", "string"),     # orchestrating client (opaque token)
+    ("n_stages", "int32"),       # stages in this workflow
+    ("stage_idx", "int32"),      # which stage this message belongs to
+    ("step_type", "string"),     # discovery_query|discovery_result|request|update|response
+    ("direction", "string"),     # c2s | s2c
+    ("src", "string"),           # opaque source endpoint token
+    ("dst", "string"),           # opaque destination endpoint token
+    ("t", "float64"),            # relative timestamp (seconds)
+    ("length", "int64"),         # wire byte length of the message (the obs(m) volume axis)
+    ("capability", "string"),    # capability named at this stage
+    ("label_visible", "bool"),   # whether the semantic label is visible at this message
+    ("mode", "string"),          # agent backend
+    ("transport", "string"),     # transport the capture ran over
+]
+
+
+def _frame(capture: dict, mode: str, transport: str) -> pd.DataFrame:
+    rows = []
+    for m in capture["messages"]:
+        row = {name: m.get(name) for name, _ in SCHEMA if name not in ("mode", "transport")}
+        row["mode"], row["transport"] = mode, transport
+        rows.append(row)
+    df = pd.DataFrame(rows, columns=[n for n, _ in SCHEMA])
+    for name, dtype in SCHEMA:
+        df[name] = df[name].astype(dtype)
+    return df
+
+
+def _features_yaml() -> list[str]:
+    return [f"  - name: {n}\n    dtype: {d}" for n, d in SCHEMA]
+
+
+def _front_matter(stats: list[dict]) -> str:
+    configs = []
+    info = []
+    for s in stats:
+        configs.append(
+            f"- config_name: {s['config']}\n"
+            f"  data_files:\n"
+            f"  - split: train\n"
+            f"    path: data/{s['config']}/train.parquet"
+        )
+        info.append(
+            f"- config_name: {s['config']}\n"
+            f"  features:\n" + "\n".join(_features_yaml()) + "\n"
+            f"  splits:\n"
+            f"  - name: train\n"
+            f"    num_examples: {s['rows']}"
+        )
+    total = sum(s["rows"] for s in stats)
+    size_bucket = ("1K<n<10K" if total < 10_000 else
+                   "10K<n<100K" if total < 100_000 else "100K<n<1M")
+    return (
+        "---\n"
+        "pretty_name: A2A-MetaTrace\n"
+        "task_categories:\n- tabular-classification\n"
+        "tags:\n"
+        "- traffic-analysis\n- metadata-privacy\n- agent\n- a2a\n"
+        "- multi-agent\n- workflow-fingerprinting\n"
+        f"size_categories:\n- {size_bucket}\n"
+        "configs:\n" + "\n".join(configs) + "\n"
+        "dataset_info:\n" + "\n".join(info) + "\n"
+        "---\n"
+    )
+
+
+def _body(stats: list[dict]) -> str:
+    rows = "\n".join(
+        f"| `{s['config']}` | {s['mode']} | {s['transport']} | {s['workflows']} | "
+        f"{s['classes']} | {s['variants']} | {s['rows']} |"
+        for s in stats
+    )
+    return f"""# A2A-MetaTrace
+
+A labeled, **metadata-only** corpus of multi-agent **A2A** (Agent-to-Agent) workflow
+traffic. Each row is one wire message reduced to what a passive network observer sees,
+`obs(m) = (src, dst, t, length, direction)`, with workflow ground-truth labels; message
+bodies are discarded. The corpus exists to study how much of a *pending agent workflow*
+leaks from communication-graph metadata alone, and to evaluate metadata-protecting
+transports against it.
+
+**Provenance (disclosed).** Workflows run over the real `a2a-sdk` protocol path
+(Agent Cards, discovery, `message/send`, SSE) against real official `a2a-samples` agent
+servers backed by real language-model calls. The workflow *compositions* and *labels*
+are ours (see `DATASHEET.md`). This is the honest provenance claim: the protocol path and
+agent behavior are real; the composition is designed.
+
+## Config
+
+| config | agent backend | transport | workflows | classes | variants | rows (messages) |
+|---|---|---|---|---|---|---|
+{rows}
+
+The corpus is captured from official `a2a-samples` agents composed into multi-agent
+workflows; transport is HTTPS-direct (the metadata-protecting transport is evaluated
+analytically; see `DATASHEET.md`).
+
+## Usage
+
+```python
+from datasets import load_dataset
+import pandas as pd
+
+ds = load_dataset("a2a-metatrace", split="train")   # message-level rows
+df = ds.to_pandas()
+
+# reconstruct workflows and their labels by grouping on trace_id
+by_wf = df.groupby("trace_id")
+labels = by_wf["task_class"].first()
+```
+
+A workflow is the unit an adversary classifies; featurize per `trace_id` (message counts,
+length stats, timing, direction n-grams) and recover `task_class`. Use the `variant`
+column for a **leave-variant-out** split (generalization to unseen compositions).
+
+## Regenerating the corpus
+
+The published Parquet is produced by capturing real official `a2a-samples` agents. To
+reproduce it end to end:
+
+1. **Get the agents.** Clone the official samples repo and point the harness at its
+   Python agents directory:
+   ```bash
+   git clone https://github.com/a2aproject/a2a-samples.git
+   export A2A_SAMPLES_DIR=$(pwd)/a2a-samples/samples/python/agents
+   ```
+2. **Provide model credentials.** The sample agents call real models:
+   - `export OPENAI_API_KEY=...` (the OpenAI- and LiteLLM-backed agents), and
+   - for the Google-ADK agents, a Vertex project via Application Default Credentials:
+     `export GOOGLE_CLOUD_PROJECT=...` and `gcloud auth application-default login`.
+
+   Keys may instead be placed in a local `.envrc` (`export KEY=VALUE` lines); see
+   `corpus/sample_agents.py` for all configuration variables.
+3. **Install and run** (Python 3.13):
+   ```bash
+   uv sync
+   uv run python -m corpus.run_corpus --runs-per-class 30   # writes results/corpus/a2a_metatrace.json
+   uv run python scripts/export_hf.py                        # writes data/ + this README
+   ```
+
+See `DATASHEET.md` for the workflow classes, provenance, and disclosed model substitutions.
+
+## What it is for
+
+- **Workflow-fingerprinting / traffic analysis** on agent interoperation traffic.
+- **Evaluating metadata-protecting transports** for agent interoperation.
+- A reproducible, provenance-disclosed alternative to purely synthetic agent-traffic models.
+
+See `DATASHEET.md` for construction, intended use, and limitations. Regenerate this card
+and the Parquet files with `uv run python scripts/export_hf.py`.
+
+## Citation
+
+```bibtex
+@misc{{a2ametatrace,
+  title  = {{A2A-MetaTrace: a metadata-only corpus of multi-agent A2A workflow traffic}},
+  author = {{Dangol, Bijaya}},
+  year   = {{2026}}
+}}
+```
+"""
+
+
+def main() -> None:
+    stats: list[dict] = []
+    for fname, config, mode, transport in CONFIGS:
+        src = CORPUS / fname
+        if not src.exists():
+            print(f"skip {config}: no capture at {src.name}")
+            continue
+        cap = json.loads(src.read_text())
+        df = _frame(cap, mode, transport)
+        out = DATA / config
+        out.mkdir(parents=True, exist_ok=True)
+        df.to_parquet(out / "train.parquet", index=False)
+        stats.append({
+            "config": config, "mode": mode, "transport": transport,
+            "rows": len(df), "workflows": int(df["trace_id"].nunique()),
+            "classes": int(df["task_class"].nunique()),
+            "variants": int(df["variant"].nunique()),
+        })
+        print(f"wrote data/{config}/train.parquet  "
+              f"({len(df)} rows, {df['trace_id'].nunique()} workflows)")
+
+    if not stats:
+        print("no captures found; run `python -m corpus.run_corpus` first")
+        return
+    (ROOT / "README.md").write_text(_front_matter(stats) + "\n" + _body(stats))
+    print(f"wrote README.md (dataset card) for {len(stats)} configs")
+
+
+if __name__ == "__main__":
+    main()

tests/test_corpus.py

@@ -0,0 +1,74 @@
+"""The A2A-MetaTrace orchestrator and variant-based classes, offline.
+
+A scripted stage runner stands in for real agent servers, so these cover the generation
+contracts that must hold before any server exists: the orchestrator emits schema-valid
+records; the class label (not the variant) becomes ``task_class``; classes stay balanced
+across their variants; every message carries a variant tag that maps back to its class;
+and every variant stage has a serving capability.
+"""
+
+from __future__ import annotations
+
+from corpus.classes import CLASSES, all_variants, capabilities, class_of
+from corpus.orchestrator import REQUIRED_FIELDS, run_corpus, run_workflow
+
+
+def _scripted_runner(variant, instance, stage_idx, capability, client_id):
+    """Discovery round-trip + request + class-dependent updates (stands in for a server)."""
+    provider = f"agent-{abs(hash(capability)) % 9000 + 1000}"
+    t = float(stage_idx)
+    recs = [
+        {"step_type": "discovery_query", "direction": "c2s", "src": client_id,
+         "dst": "registry", "t": t, "length": 40, "label_visible": True},
+        {"step_type": "discovery_result", "direction": "s2c", "src": "registry",
+         "dst": client_id, "t": t + 0.01, "length": 60, "label_visible": False},
+        {"step_type": "request", "direction": "c2s", "src": client_id,
+         "dst": provider, "t": t + 0.02, "length": 200, "label_visible": False},
+    ]
+    n_updates = 1 + (len(capability) + stage_idx) % 4
+    for u in range(n_updates):
+        recs.append({"step_type": "update", "direction": "s2c", "src": provider,
+                     "dst": client_id, "t": t + 0.03 + 0.01 * u, "length": 1500,
+                     "label_visible": False})
+    recs.append({"step_type": "response", "direction": "s2c", "src": provider,
+                 "dst": client_id, "t": t + 0.1, "length": 800, "label_visible": False})
+    return recs
+
+
+def test_records_schema_and_class_label() -> None:
+    cls = CLASSES[0]
+    variant = cls.variants[0]
+    recs = run_workflow(variant, 0, task_class=cls.name, trace_id=0,
+                        client_id="client-001", stage_runner=_scripted_runner)
+    assert recs
+    for r in recs:
+        assert REQUIRED_FIELDS <= r.keys()
+        assert r["task_class"] == cls.name          # the CLASS, not the variant
+        assert r["variant"] == variant.name          # variant rides along for grouping
+
+
+def test_corpus_balanced_across_classes() -> None:
+    cap = run_corpus(CLASSES, runs_per_class=12, stage_runner=_scripted_runner)
+    # one workflow per trace_id; its class is constant across the trace's messages
+    class_of_trace = {m["trace_id"]: m["task_class"] for m in cap["messages"]}
+    counts: dict[str, int] = {}
+    for cls_name in class_of_trace.values():
+        counts[cls_name] = counts.get(cls_name, 0) + 1
+    assert set(counts) == {c.name for c in CLASSES}
+    # each class gets exactly runs_per_class workflows (split across its variants)
+    assert all(v == 12 for v in counts.values())
+
+
+def test_variant_tag_present_for_every_message() -> None:
+    cap = run_corpus(CLASSES, runs_per_class=6, stage_runner=_scripted_runner)
+    variant_names = {v.name for _, v in all_variants()}
+    assert all(m["variant"] in variant_names for m in cap["messages"])
+    # variant maps back to its class
+    for m in cap["messages"]:
+        assert class_of(m["variant"]) == m["task_class"]
+
+
+def test_capabilities_cover_all_variant_stages() -> None:
+    caps = set(capabilities())
+    for _, v in all_variants():
+        assert set(v.stages) <= caps