@@ -141,7 +141,7 @@ pinned by a test:
   ID is case-sensitive. The URL an HTTP client uses for a peer's service
   therefore carries the peer ID in the path,
   `http://mesh/sam/<peer-id>/<type>/<name>/<path>`, the shape of `sam-node`'s
-  egress proxy and of an agent card it rewrote; the host is ignored.
+  egress proxy and of an agent card rewritten for the mesh; the host is ignored.
 - A member that publishes nothing has announced no address, so nothing in
   the DHT or a router's peerstore names one. `sam-node` dials
   `/p2p/<router>/p2p-circuit` for every router it authenticated with when
@@ -520,7 +520,13 @@ holds against the control plane's records.
   `open_http_request` / `fetchOverStream` return once the headers are in
   and stream the body; `MeshTransport` (httpx) and `session.fetch()`
   (fetch) carry a client's requests to the peer a mesh URL names. The A2A
-  SDK's client takes either without changes.
+  SDK's client takes either without changes. The card of an agent behind a
+  `sam-node` names the agent's own address; a GET of the well-known card
+  path or of the service root is answered the way the node's egress proxy
+  answers it: the SDK fetches the card itself, with identity encoding, and
+  serves it rewritten (`rewriteAgentCard` / `rewrite_agent_card`): HTTP
+  interfaces point at the mesh URL, gRPC ones are dropped, signatures go.
+  Streaming stays as the agent declares it, since the transport streams.
 - `sam-node`: a peer it knows no address for is dialed through every
   router it authenticated with, so its egress proxy reaches an agent by
   peer ID (`preparePeerAddrs`).
 
@@ -47,6 +47,7 @@ export { LabelsNotSatisfiedError, StreamTransport, openMCPSession, requireEgress
 export { AuthorizationError, authorizeCaller, type AuthorizeRequest, type ProviderAuthorizerOptions } from "./authorizer.ts";
 export {
   DEFAULT_A2A_NAME,
+  AGENT_CARD_PATH,
   HTTP_HANDLER_OPTIONS,
   HTTP_PROTOCOL,
   MESH_PATH_PREFIX,
@@ -57,6 +58,7 @@ export {
   httpRequestOverStream,
   meshHTTPTarget,
   meshURL,
+  rewriteAgentCard,
   splitMeshURL,
   type A2AEndpoint,
   type A2AEndpointSpec,
 
@@ -29,6 +29,7 @@ import { after, before, test } from "node:test";
 import { loadBiscuit } from "./biscuit.ts";
 import { ROLE_NODE } from "./controlplane.ts";
 import {
+  AGENT_CARD_PATH,
   HTTP_PROTOCOL,
   a2aEndpoint,
   admitIngress,
@@ -37,6 +38,7 @@ import {
   httpRequestOverStream,
   meshHTTPTarget,
   meshURL,
+  rewriteAgentCard,
   splitMeshURL,
   type ProviderOptions,
 } from "./libp2p-http.ts";
@@ -55,7 +57,7 @@ let callerBiscuit: Uint8Array;
 let guestBiscuit: Uint8Array;
 let backend: http.Server;
 let backendURL: string;
-const backendSeen: { method: string; url: string; peer: string | undefined; body: string }[] = [];
+const backendSeen: { method: string; url: string; peer: string | undefined; body: string; encoding: string | undefined }[] = [];
 const listenerSeen: { url: string; peer: string | undefined; biscuit: string | undefined }[] = [];
 const authorized: string[] = [];
 
@@ -98,14 +100,40 @@ function providerOptions(biscuit: Uint8Array): ProviderOptions {
   };
 }
 
+const STOCK_CARD = {
+  name: "echo-agent",
+  version: "1.0.0",
+  capabilities: { streaming: true, pushNotifications: false },
+  supportedInterfaces: [
+    { url: "http://127.0.0.1:7777/", protocolBinding: "JSONRPC", protocolVersion: "1.0" },
+    { url: "127.0.0.1:50051", protocolBinding: "GRPC", protocolVersion: "1.0" },
+  ],
+  signatures: [{ protected: "eyJhbGciOiJFUzI1NiJ9", signature: "c3RhbGU" }],
+  skills: [],
+  defaultInputModes: ["text/plain"],
+  defaultOutputModes: ["text/plain"],
+};
+
 // Stands in for an A2A server beside the agent: echoes the request and, on
 // /stream, answers with three SSE events as message/stream would.
 function fakeA2AServer(req: http.IncomingMessage, res: http.ServerResponse): void {
   let body = "";
   req.on("data", (c: Buffer) => (body += c.toString()));
   req.on("end", () => {
-    backendSeen.push({ method: req.method ?? "", url: req.url ?? "", peer: req.headers["x-peer-id"] as string | undefined, body });
+    backendSeen.push({ method: req.method ?? "", url: req.url ?? "", peer: req.headers["x-peer-id"] as string | undefined, body, encoding: req.headers["accept-encoding"] as string | undefined });
     assert.equal(req.headers["x-sam-biscuit"], undefined, "biscuit leaked to the backend");
+    if (req.url === `/${AGENT_CARD_PATH}` && req.headers["x-card"] === "missing") {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("no card");
+      return;
+    }
+    if (req.url === `/${AGENT_CARD_PATH}`) {
+      const grpcOnly = req.headers["x-card"] === "grpc-only";
+      const supportedInterfaces = STOCK_CARD.supportedInterfaces.filter((i) => !grpcOnly || i.protocolBinding === "GRPC");
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ...STOCK_CARD, supportedInterfaces }));
+      return;
+    }
     if (req.url === "/stream") {
       res.writeHead(200, { "content-type": "text/event-stream" });
       let i = 0;
@@ -242,6 +270,49 @@ test("a fetch over the stream delivers an SSE body event by event", async () =>
   );
 });
 
+test("the card of an agent behind a node comes back rewritten for the mesh, as sam-node serves it", async () => {
+  const conn = await dial();
+  const base = meshURL(agent.peerId.toString(), "a2a://agent");
+  const response = await fetchOverStream(conn, callerBiscuit, new Request(`${base}/${AGENT_CARD_PATH}`));
+  assert.equal(response.status, 200);
+  assert.equal(response.headers.get("content-type"), "application/json");
+  const card = (await response.json()) as Record<string, unknown>;
+  assert.deepEqual(card.supportedInterfaces, [{ url: base, protocolBinding: "JSONRPC", protocolVersion: "1.0" }]);
+  assert.deepEqual(card.capabilities, { streaming: true, pushNotifications: false });
+  assert.equal("signatures" in card, false);
+  assert.equal(card.name, "echo-agent");
+  assert.deepEqual(card.skills, []);
+  assert.equal(backendSeen[backendSeen.length - 1]?.url, `/${AGENT_CARD_PATH}`);
+
+  // The bare service root serves the card too, the way a2a-go resolves a pathful base URL.
+  assert.deepEqual(await (await fetchOverStream(conn, callerBiscuit, new Request(base))).json(), card);
+  assert.equal(backendSeen[backendSeen.length - 1]?.url, `/${AGENT_CARD_PATH}`);
+  await fetchOverStream(conn, callerBiscuit, new Request(`${base}/${AGENT_CARD_PATH}`, { headers: { "accept-encoding": "x-test-only" } }));
+  assert.notEqual(backendSeen[backendSeen.length - 1]?.encoding, "x-test-only", "the client's accept-encoding reached the agent");
+
+  const missing = await fetchOverStream(conn, callerBiscuit, new Request(`${base}/${AGENT_CARD_PATH}`, { headers: { "x-card": "missing" } }));
+  assert.equal(missing.status, 404);
+  assert.equal(await missing.text(), "no card");
+
+  const raw = await httpRequestOverStream(conn, callerBiscuit, "a2a://agent", `/${AGENT_CARD_PATH}`);
+  assert.deepEqual(JSON.parse(raw.text()), card);
+
+  const refused = await fetchOverStream(conn, callerBiscuit, new Request(`${base}/${AGENT_CARD_PATH}`, { headers: { "x-card": "grpc-only" } }));
+  assert.equal(refused.status, 502);
+  assert.match(await refused.text(), /no supported interface the mesh can carry/);
+
+  const other = await fetchOverStream(conn, callerBiscuit, new Request(`${base}/card`));
+  assert.deepEqual(await other.json(), { path: "/card", echo: "" });
+});
+
+test("rewriteAgentCard keeps only what the mesh carries", () => {
+  assert.throws(() => rewriteAgentCard([], "http://mesh/x"), /not a JSON object/);
+  assert.throws(() => rewriteAgentCard({ supportedInterfaces: [] }, "http://mesh/x"), /no supported interface/);
+  assert.deepEqual(rewriteAgentCard({ supportedInterfaces: [{ url: "x", protocolBinding: "http+json" }] }, "http://mesh/x"), {
+    supportedInterfaces: [{ url: "http://mesh/x", protocolBinding: "http+json" }],
+  });
+});
+
 test("a fetch handler sees the caller and the path, and its streaming body goes out as it is written", async () => {
   const conn = await dial(handlerAgent);
   const res = await httpRequestOverStream(conn, callerBiscuit, "a2a://agent", "/tasks?x=1", { method: "POST", headers: { "x-sam-biscuit": "spoof", "content-type": "text/plain" }, body: "hello" });
 
@@ -61,12 +61,17 @@ export const DEFAULT_A2A_NAME = "agent";
 
 /**
  * The path prefix of a mesh URL, http://mesh/sam/<peer-id>/<type>/<name>/<path>:
- * the shape of sam-node's egress proxy and of an agent card it rewrote. The
- * host is ignored; the peer ID is in the path because URL parsers lowercase
- * the host and a peer ID is case-sensitive.
+ * the shape of sam-node's egress proxy and of an agent card rewritten for the
+ * mesh, by sam-node or by this SDK. The host is ignored; the peer ID is in the
+ * path because URL parsers lowercase the host and a peer ID is case-sensitive.
  */
 export const MESH_PATH_PREFIX = "/sam/";
 
+/** The well-known agent card location (A2A spec / RFC 8615). */
+export const AGENT_CARD_PATH = ".well-known/agent-card.json";
+
+const MAX_AGENT_CARD_BYTES = 1 << 20;
+
 /** Largest request body the ingress reads whole for a handler or url target. */
 export const MAX_INGRESS_BODY_BYTES = 8 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 60_000;
@@ -387,6 +392,94 @@ export function splitMeshURL(url: URL): { peerId: string; target: string } {
   return { peerId, target: "/" + rest.join("/") + url.search };
 }
 
+/** The bare service root counts too: a2a-go treats a pathful base URL as the card location. */
+function agentCardService(method: string, target: string): string | undefined {
+  const m = /^\/a2a\/([^/?]+)(?:\/(?:\.well-known\/agent-card\.json)?)?(?:\?.*)?$/.exec(target);
+  return method === "GET" && m !== null ? `a2a://${m[1]}` : undefined;
+}
+
+/**
+ * An agent card rebuilt for the mesh, as sam-node's egress proxy serves it:
+ * HTTP interfaces point at base, gRPC ones go, signatures no longer match.
+ * Streaming stays as declared, this transport streams. Throws when no interface remains.
+ */
+export function rewriteAgentCard(card: unknown, base: string): Record<string, unknown> {
+  if (typeof card !== "object" || card === null || Array.isArray(card)) {
+    throw new Error("agent card is not a JSON object");
+  }
+  const out = { ...(card as Record<string, unknown>) };
+  delete out.signatures;
+  const interfaces = Array.isArray(out.supportedInterfaces) ? (out.supportedInterfaces as unknown[]) : [];
+  const kept = interfaces.filter(carriedOverHTTP).map((iface) => ({ ...(iface as Record<string, unknown>), url: base }));
+  if (kept.length === 0) {
+    throw new Error("agent card advertises no supported interface the mesh can carry (JSONRPC or HTTP+JSON); is the agent serving a pre-1.0 A2A card?");
+  }
+  return { ...out, supportedInterfaces: kept };
+}
+
+/** Whether an interface's binding can traverse the mesh; gRPC needs its own connection. */
+function carriedOverHTTP(iface: unknown): boolean {
+  const binding = typeof iface === "object" && iface !== null ? (iface as { protocolBinding?: unknown }).protocolBinding : undefined;
+  return typeof binding === "string" && ["JSONRPC", "HTTP+JSON"].includes(binding.toUpperCase());
+}
+
+/**
+ * Impersonates the agent's card endpoint as sam-node's egress proxy does: holds
+ * the client's request, fetches the card itself with identity encoding, and
+ * answers with it regenerated; the agent's own non-200 is relayed as it is.
+ */
+async function serveAgentCard(conn: Connection, biscuit: Uint8Array, request: Request, options: HTTPStreamOptions, service: string): Promise<Response> {
+  const base = meshURL(conn.remotePeer.toString(), service);
+  const headers = new Headers(request.headers);
+  headers.delete("accept-encoding");
+  let response: Response;
+  try {
+    response = await sendOverStream(conn, biscuit, new Request(`${base}/${AGENT_CARD_PATH}`, { headers, signal: request.signal }), options);
+  } catch (err) {
+    return badGateway(`agent card fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (response.status !== 200) {
+    return response;
+  }
+  let card: unknown;
+  try {
+    card = JSON.parse(new TextDecoder().decode(await readLimited(response.body, MAX_AGENT_CARD_BYTES)));
+  } catch {
+    return badGateway("agent card is not valid JSON");
+  }
+  try {
+    return new Response(JSON.stringify(rewriteAgentCard(card, base)), { status: 200, headers: { "content-type": "application/json" } });
+  } catch (err) {
+    return badGateway(err instanceof Error ? err.message : String(err));
+  }
+}
+
+function badGateway(reason: string): Response {
+  return new Response(`Bad Gateway: ${reason}`, { status: 502, headers: { "content-type": "text/plain" } });
+}
+
+/** The first limit bytes of a body, the rest dropped, as io.LimitReader bounds the node. */
+async function readLimited(body: ReadableStream<Uint8Array> | null, limit: number): Promise<Uint8Array> {
+  const chunks: Uint8Array[] = [];
+  let n = 0;
+  if (body !== null) {
+    const reader = body.getReader();
+    for (let next = await reader.read(); !next.done && n < limit; next = await reader.read()) {
+      const chunk = next.value.subarray(0, limit - n);
+      chunks.push(chunk);
+      n += chunk.length;
+    }
+    await reader.cancel();
+  }
+  const out = new Uint8Array(n);
+  let at = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, at);
+    at += chunk.length;
+  }
+  return out;
+}
+
 export interface HTTPStreamOptions {
   /** The agent this request is made for. */
   agent?: string;
@@ -398,9 +491,16 @@ export interface HTTPStreamOptions {
  * Client side of /libp2p-http, as go-libp2p-http's RoundTripper: one stream
  * per request, plain HTTP/1.1 with Host set to the peer ID and the biscuit in
  * X-Sam-Biscuit. Resolves once the response headers are in; the body streams
- * after, so an SSE response is consumed as the peer sends it.
+ * after, so an SSE response is consumed as the peer sends it. An agent card
+ * is served rewritten for the mesh (rewriteAgentCard), as sam-node serves one.
  */
 export async function fetchOverStream(conn: Connection, biscuit: Uint8Array, request: Request, options: HTTPStreamOptions = {}): Promise<Response> {
+  const { target } = splitMeshURL(new URL(request.url));
+  const service = agentCardService(request.method, target);
+  return service === undefined ? sendOverStream(conn, biscuit, request, options) : serveAgentCard(conn, biscuit, request, options, service);
+}
+
+async function sendOverStream(conn: Connection, biscuit: Uint8Array, request: Request, options: HTTPStreamOptions): Promise<Response> {
   const { target } = splitMeshURL(new URL(request.url));
   const peerId = conn.remotePeer.toString();
   // One controller ends the exchange: the caller's signal at any time, the
 
@@ -34,6 +34,7 @@
 from .httpx_transport import MESH_PATH_PREFIX, MeshTransport, split_mesh_url
 from .identity import Identity, canonical_peer_id, libp2p_public_key, peer_id_from_public_key, verify_ed25519
 from .libp2p_http import (
+    AGENT_CARD_PATH,
     DEFAULT_A2A_NAME,
     HTTP_PROTOCOL,
     A2AEndpoint,
@@ -45,7 +46,9 @@
     http_ingress_handler,
     http_request_over_stream,
     mesh_http_target,
+    mesh_url,
     open_http_request,
+    rewrite_agent_card,
 )
 from .mcp_client import LabelsNotSatisfiedError, ToolCallResult, ToolInfo, open_mcp_session, require_egress_labels, require_labels
 from .mesh import AgentMesh, ControlPlaneSync
@@ -57,6 +60,7 @@
 
 __all__ = [
     "A2AEndpoint",
+    "AGENT_CARD_PATH",
     "AUTH_PROTOCOL",
     "AdmittedRouter",
     "AgentMesh",
@@ -111,6 +115,7 @@
     "http_request_over_stream",
     "libp2p_public_key",
     "mesh_http_target",
+    "mesh_url",
     "open_http_request",
     "open_mcp_session",
     "parse_service_target",
@@ -122,6 +127,7 @@
     "require_role",
     "reserve_relay",
     "service_key",
+    "rewrite_agent_card",
     "split_mesh_url",
     "validate_control_plane_url",
     "verify_ed25519",
 
@@ -20,22 +20,23 @@
     await client.post("http://mesh/sam/<peer-id>/a2a/agent", json=...)
 
 The URL has the shape sam-node's egress proxy takes, /sam/<peer-id>/<type>/
-<name>/<path>, so an agent card a sam-node rewrote for the mesh works here as
-it is. The host is ignored: httpx lowercases it, and a peer ID is not
-case-insensitive. Response bodies stream, so `message/stream` works."""
+<name>/<path>. The card of an agent behind a sam-node comes back rewritten to
+that shape, as the node's egress proxy serves it, so a stock A2A client
+bootstraps from it unchanged. The host is ignored: httpx lowercases it, and a
+peer ID is not case-insensitive. Response bodies stream, so `message/stream`
+works."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, AsyncIterator
 
 import httpx
 
-from .libp2p_http import StreamedResponse, open_http_request
+from .libp2p_http import MESH_PATH_PREFIX, StreamedResponse, open_http_request
 
 if TYPE_CHECKING:
     from .session import MeshSession
 
-MESH_PATH_PREFIX = "/sam/"
 _REQUEST_TIMEOUT = 60.0