@agentmesh-p2p/sdk 0.0.0-stage → 0.1.0

package/dist/identity.d.ts

@@ -0,0 +1,31 @@
+/** The libp2p protobuf encoding of an ed25519 public key. */
+export declare function libp2pPublicKey(publicKeyRaw: Uint8Array): Uint8Array;
+/** The peer ID libp2p derives from an ed25519 public key (base58btc, "12D3Koo..."). */
+export declare function peerIdFromPublicKey(publicKeyRaw: Uint8Array): string;
+/**
+ * The base58btc form of a peer ID written in any encoding libp2p accepts
+ * (base58btc multihash, CIDv1). Every key, ban set and comparison in Agent Mesh is
+ * on this form, as peer.ID.String() in Go; a string read off the wire or
+ * from a caller goes through here before it is used as one. Throws when the
+ * text is not a peer ID at all.
+ */
+export declare function canonicalPeerId(text: string): string;
+export declare class Identity {
+    #private;
+    /** Raw 32-byte ed25519 public key. */
+    readonly publicKeyRaw: Uint8Array;
+    readonly peerId: string;
+    private constructor();
+    static generate(): Identity;
+    static fromSeed(seed: Uint8Array): Identity;
+    /** Loads the libp2p protobuf private key encoding, the format agentmesh-node persists. */
+    static fromLibp2pPrivateKey(bytes: Uint8Array): Identity;
+    /** The libp2p protobuf private key encoding (seed || public key). */
+    toLibp2pPrivateKey(): Uint8Array;
+    /** The libp2p protobuf public key encoding, what the control plane stores. */
+    get libp2pPublicKey(): Uint8Array;
+    sign(data: Uint8Array): Uint8Array;
+    verify(data: Uint8Array, signature: Uint8Array): boolean;
+}
+/** Verifies an ed25519 signature with a raw 32-byte public key. */
+export declare function verifyEd25519(publicKeyRaw: Uint8Array, data: Uint8Array, signature: Uint8Array): boolean;

package/dist/identity.js

@@ -0,0 +1,125 @@
+// Copyright 2026 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.
+// A mesh identity is an ed25519 key pair. Its peer ID is the one libp2p
+// derives, so the same key works in the SDK, in agentmesh-node and on the wire.
+// The arithmetic is @noble/curves, the implementation libp2p itself uses,
+// so an identity is built and used the same way in Node and in a browser.
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { peerIdFromString } from "@libp2p/peer-id";
+import { encodeBase58 } from "./base58.js";
+import { bytesEqual, concatBytes as concat } from "./bytes.js";
+const PUBLIC_KEY_SIZE = 32;
+const SEED_SIZE = 32;
+const SIGNATURE_SIZE = 64;
+// libp2p crypto.proto PublicKey{Type: Ed25519 (1), Data: <32 bytes>}.
+const LIBP2P_PUBLIC_KEY_PREFIX = Uint8Array.of(0x08, 0x01, 0x12, 0x20);
+// libp2p crypto.proto PrivateKey{Type: Ed25519 (1), Data: <seed || public>}.
+const LIBP2P_PRIVATE_KEY_PREFIX = Uint8Array.of(0x08, 0x01, 0x12, 0x40);
+// multihash: identity function (0x00), digest length 36.
+const IDENTITY_MULTIHASH_PREFIX = Uint8Array.of(0x00, 0x24);
+function startsWith(bytes, prefix) {
+    return prefix.every((b, i) => bytes[i] === b);
+}
+// RFC 8032 verification, as Go crypto/ed25519 and node:crypto do it; the
+// looser ZIP 215 rules noble defaults to accept signatures those reject.
+function verifyRaw(publicKeyRaw, data, signature) {
+    if (publicKeyRaw.length !== PUBLIC_KEY_SIZE || signature.length !== SIGNATURE_SIZE) {
+        return false;
+    }
+    try {
+        return ed25519.verify(signature, data, publicKeyRaw, { zip215: false });
+    }
+    catch {
+        return false;
+    }
+}
+/** The libp2p protobuf encoding of an ed25519 public key. */
+export function libp2pPublicKey(publicKeyRaw) {
+    if (publicKeyRaw.length !== PUBLIC_KEY_SIZE) {
+        throw new Error(`ed25519 public key must be ${PUBLIC_KEY_SIZE} bytes, got ${publicKeyRaw.length}`);
+    }
+    return concat(LIBP2P_PUBLIC_KEY_PREFIX, publicKeyRaw);
+}
+/** The peer ID libp2p derives from an ed25519 public key (base58btc, "12D3Koo..."). */
+export function peerIdFromPublicKey(publicKeyRaw) {
+    return encodeBase58(concat(IDENTITY_MULTIHASH_PREFIX, libp2pPublicKey(publicKeyRaw)));
+}
+/**
+ * The base58btc form of a peer ID written in any encoding libp2p accepts
+ * (base58btc multihash, CIDv1). Every key, ban set and comparison in Agent Mesh is
+ * on this form, as peer.ID.String() in Go; a string read off the wire or
+ * from a caller goes through here before it is used as one. Throws when the
+ * text is not a peer ID at all.
+ */
+export function canonicalPeerId(text) {
+    try {
+        return peerIdFromString(text).toString();
+    }
+    catch (err) {
+        throw new Error(`${JSON.stringify(text)} is not a peer ID: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export class Identity {
+    #seed;
+    /** Raw 32-byte ed25519 public key. */
+    publicKeyRaw;
+    peerId;
+    constructor(seed) {
+        if (seed.length !== SEED_SIZE) {
+            throw new Error(`ed25519 seed must be ${SEED_SIZE} bytes, got ${seed.length}`);
+        }
+        this.#seed = new Uint8Array(seed);
+        this.publicKeyRaw = ed25519.getPublicKey(this.#seed);
+        this.peerId = peerIdFromPublicKey(this.publicKeyRaw);
+    }
+    static generate() {
+        const seed = new Uint8Array(SEED_SIZE);
+        crypto.getRandomValues(seed);
+        return new Identity(seed);
+    }
+    static fromSeed(seed) {
+        return new Identity(seed);
+    }
+    /** Loads the libp2p protobuf private key encoding, the format agentmesh-node persists. */
+    static fromLibp2pPrivateKey(bytes) {
+        if (bytes.length !== LIBP2P_PRIVATE_KEY_PREFIX.length + 64 || !startsWith(bytes, LIBP2P_PRIVATE_KEY_PREFIX)) {
+            throw new Error("not a libp2p ed25519 private key");
+        }
+        const seed = bytes.subarray(LIBP2P_PRIVATE_KEY_PREFIX.length, LIBP2P_PRIVATE_KEY_PREFIX.length + SEED_SIZE);
+        const pub = bytes.subarray(LIBP2P_PRIVATE_KEY_PREFIX.length + SEED_SIZE);
+        const id = new Identity(seed);
+        if (!bytesEqual(pub, id.publicKeyRaw)) {
+            throw new Error("libp2p private key: public half does not match the seed");
+        }
+        return id;
+    }
+    /** The libp2p protobuf private key encoding (seed || public key). */
+    toLibp2pPrivateKey() {
+        return concat(LIBP2P_PRIVATE_KEY_PREFIX, this.#seed, this.publicKeyRaw);
+    }
+    /** The libp2p protobuf public key encoding, what the control plane stores. */
+    get libp2pPublicKey() {
+        return libp2pPublicKey(this.publicKeyRaw);
+    }
+    sign(data) {
+        return ed25519.sign(data, this.#seed);
+    }
+    verify(data, signature) {
+        return verifyRaw(this.publicKeyRaw, data, signature);
+    }
+}
+/** Verifies an ed25519 signature with a raw 32-byte public key. */
+export function verifyEd25519(publicKeyRaw, data, signature) {
+    return verifyRaw(publicKeyRaw, data, signature);
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { AgentMesh, CredentialRetiredError, type AgentMeshOptions, type ControlPlaneSync, type EnrollOptions, type JwtSource } from "./mesh.ts";
+export { Identity, canonicalPeerId, peerIdFromPublicKey, libp2pPublicKey, verifyEd25519 } from "./identity.ts";
+export { ControlPlaneClient, ControlPlaneError, EnrollmentRejectedError, InsecureControlPlaneURLError, KeysNotTrustedError, ROLE_NODE, validateControlPlaneURL, verifyKeysResponse, type ControlPlaneClientOptions, type Enrollment, type EnrollBootstrapParams, type PolicyRulesParams, type RegisterParams, type RefreshParams, type RefreshResult, } from "./controlplane.ts";
+export { attenuateCredential, credentialFromJSON, credentialTimeToLiveSeconds, credentialToJSON, decodeAuthResponse, encodeAuthFrame, sealCredential, withCredentialMethods, type MeshCredential, } from "./credential.ts";
+export { egressChallenge, enrollChallenge, enrollStatusChallenge, nodesCatalogChallenge, policiesChallenge, refreshChallenge, registerChallenge, revocationsChallenge, } from "./challenges.ts";
+export { DEFAULT_ROUTERS, MeshSession, ROUTER_REDIAL_BACKOFFS_MS, candidatesFromRouterInfos, selectRouters, type AdmittedRouter, type DiscoveredProvider, type JoinOptions, type Peer, type RouterCandidate, type SelectRoutersOptions, type ToolCallResult, } from "./session.ts";
+export { BiscuitVerificationError, ROLE_ROUTER, attenuateBiscuit, requireRole, sealBiscuit, verifyPeerBiscuit, type VerifiedBiscuit, } from "./biscuit.ts";
+export { decodeTARBlockPayload, effectiveTARExpiration, encodeTARBlockFact, encodeTARBlockPayload, evaluateTaskRules, matchHTTPPath, matchServicePattern, matchTaskRule, parseTARBlockSource, validateHTTPGrantPath, validateServicePattern, validateTaskAuthorizationRule, validateTaskRule, type TaskRequestContext, } from "./tar.ts";
+export { AUTH_HANDLER_OPTIONS, AUTH_PROTOCOL, GOAWAY_MAX_RETRY_AFTER_MS, GOAWAY_PROTOCOL, GOAWAY_STREAM_TIMEOUT_MS, MAX_GOAWAY_MESSAGE_BYTES, MCP_PROTOCOL, ROUTER_SHUN_DURATION_MS, AuthRejectedError, authenticateWithPeer, authStreamHandler, clampGoAwayRetryAfterMs, goAwayReasonName, goAwayStreamHandler, type GoAwayServerOptions, } from "./auth.ts";
+export { createMeshHost, type MeshHost, type MeshHostOptions } from "./host.ts";
+export { DIRECTORY_PROTOCOL, DirectoryError, isServiceType, parseServiceTarget, peerKey, serviceKey, type ServiceType } from "./discovery.ts";
+export { LabelsNotSatisfiedError, StreamTransport, openMCPSession, requireEgressLabels, requireLabels, type MCPSession, type MCPSessionOptions } from "./mcp.ts";
+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, a2aEndpoint, admitIngress, fetchOverStream, httpIngressHandler, httpRequestOverStream, meshHTTPTarget, meshURL, rewriteAgentCard, splitMeshURL, type A2AEndpoint, type A2AEndpointSpec, type HTTPHandler, type HTTPRequestOptions, type HTTPResponse, type HTTPStreamOptions, type NodeRequestListener, type ProviderOptions, } from "./libp2p-http.ts";
+export { ingressHandler } from "./platform/ingress.ts";
+export type { StateStore } from "./platform/types.ts";
+export { BASELINE_DATALOG } from "./gen/datalog.ts";
+export { BanSet, EVENT_FRESHNESS_MS, GOSSIP_EVENTS_TOPIC, verifyMeshEvent, type VerifiedMeshEvent } from "./sync.ts";

package/dist/index.js

@@ -0,0 +1,30 @@
+// Copyright 2026 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.
+export { AgentMesh, CredentialRetiredError } from "./mesh.js";
+export { Identity, canonicalPeerId, peerIdFromPublicKey, libp2pPublicKey, verifyEd25519 } from "./identity.js";
+export { ControlPlaneClient, ControlPlaneError, EnrollmentRejectedError, InsecureControlPlaneURLError, KeysNotTrustedError, ROLE_NODE, validateControlPlaneURL, verifyKeysResponse, } from "./controlplane.js";
+export { attenuateCredential, credentialFromJSON, credentialTimeToLiveSeconds, credentialToJSON, decodeAuthResponse, encodeAuthFrame, sealCredential, withCredentialMethods, } from "./credential.js";
+export { egressChallenge, enrollChallenge, enrollStatusChallenge, nodesCatalogChallenge, policiesChallenge, refreshChallenge, registerChallenge, revocationsChallenge, } from "./challenges.js";
+export { DEFAULT_ROUTERS, MeshSession, ROUTER_REDIAL_BACKOFFS_MS, candidatesFromRouterInfos, selectRouters, } from "./session.js";
+export { BiscuitVerificationError, ROLE_ROUTER, attenuateBiscuit, requireRole, sealBiscuit, verifyPeerBiscuit, } from "./biscuit.js";
+export { decodeTARBlockPayload, effectiveTARExpiration, encodeTARBlockFact, encodeTARBlockPayload, evaluateTaskRules, matchHTTPPath, matchServicePattern, matchTaskRule, parseTARBlockSource, validateHTTPGrantPath, validateServicePattern, validateTaskAuthorizationRule, validateTaskRule, } from "./tar.js";
+export { AUTH_HANDLER_OPTIONS, AUTH_PROTOCOL, GOAWAY_MAX_RETRY_AFTER_MS, GOAWAY_PROTOCOL, GOAWAY_STREAM_TIMEOUT_MS, MAX_GOAWAY_MESSAGE_BYTES, MCP_PROTOCOL, ROUTER_SHUN_DURATION_MS, AuthRejectedError, authenticateWithPeer, authStreamHandler, clampGoAwayRetryAfterMs, goAwayReasonName, goAwayStreamHandler, } from "./auth.js";
+export { createMeshHost } from "./host.js";
+export { DIRECTORY_PROTOCOL, DirectoryError, isServiceType, parseServiceTarget, peerKey, serviceKey } from "./discovery.js";
+export { LabelsNotSatisfiedError, StreamTransport, openMCPSession, requireEgressLabels, requireLabels } from "./mcp.js";
+export { AuthorizationError, authorizeCaller } from "./authorizer.js";
+export { DEFAULT_A2A_NAME, AGENT_CARD_PATH, HTTP_HANDLER_OPTIONS, HTTP_PROTOCOL, MESH_PATH_PREFIX, a2aEndpoint, admitIngress, fetchOverStream, httpIngressHandler, httpRequestOverStream, meshHTTPTarget, meshURL, rewriteAgentCard, splitMeshURL, } from "./libp2p-http.js";
+export { ingressHandler } from "./platform/ingress.js";
+export { BASELINE_DATALOG } from "./gen/datalog.js";
+export { BanSet, EVENT_FRESHNESS_MS, GOSSIP_EVENTS_TOPIC, verifyMeshEvent } from "./sync.js";

package/dist/libp2p-http-node.d.ts

@@ -0,0 +1,17 @@
+import type { Stream, StreamHandler } from "@libp2p/interface";
+import { Duplex } from "node:stream";
+import { type A2AEndpoint, type ProviderOptions } from "./libp2p-http.ts";
+interface StreamSocket extends Duplex {
+    remotePeer: string;
+}
+/**
+ * Bridges a libp2p stream to a Node Duplex so Node's own HTTP parser and
+ * client can run over it.
+ */
+export declare function streamToNodeDuplex(stream: Stream, remotePeer: string): StreamSocket;
+/**
+ * Server side of /libp2p-http on Node: a listener target is served by Node's
+ * HTTP server on the stream, any other by the runtime-neutral ingress.
+ */
+export declare function nodeIngressHandler(endpoint: A2AEndpoint, options: ProviderOptions): StreamHandler;
+export {};

package/dist/libp2p-http-node.js

@@ -0,0 +1,116 @@
+// Copyright 2026 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.
+import http from "node:http";
+import { Duplex } from "node:stream";
+import { AUTH_HANDSHAKE_TIMEOUT_MS } from "./auth.js";
+import { HEADER_PEER_ID, HEADER_MESH_BISCUIT, HEADER_MESH_NO_TRAILING_SLASH, admitIngress, httpIngressHandler, } from "./libp2p-http.js";
+/**
+ * Bridges a libp2p stream to a Node Duplex so Node's own HTTP parser and
+ * client can run over it.
+ */
+export function streamToNodeDuplex(stream, remotePeer) {
+    const duplex = new Duplex({
+        read() {
+            stream.resume();
+        },
+        write(chunk, _encoding, callback) {
+            if (stream.send(chunk)) {
+                callback();
+            }
+            else {
+                stream.addEventListener("drain", () => callback(), { once: true });
+            }
+        },
+        final(callback) {
+            stream.close().then(() => callback(), (err) => callback(err));
+        },
+        destroy(err, callback) {
+            if (err !== null) {
+                stream.abort(err);
+            }
+            else {
+                void stream.close().catch(() => { });
+            }
+            callback(err);
+        },
+    });
+    duplex.remotePeer = remotePeer;
+    stream.addEventListener("message", (evt) => {
+        if (!duplex.push(Buffer.from(evt.data.subarray()))) {
+            stream.pause();
+        }
+    });
+    const end = () => {
+        if (!duplex.readableEnded) {
+            duplex.push(null);
+        }
+    };
+    stream.addEventListener("remoteCloseWrite", end);
+    stream.addEventListener("close", end);
+    return duplex;
+}
+function nodeHeaders(req) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers)) {
+        for (const v of Array.isArray(value) ? value : value === undefined ? [] : [value]) {
+            headers.append(name, v);
+        }
+    }
+    return headers;
+}
+async function serveListener(req, res, endpoint, listener, options) {
+    const remotePeer = req.socket.remotePeer;
+    const admission = await admitIngress({ method: req.method ?? "GET", target: req.url ?? "/", headers: nodeHeaders(req), remotePeer }, endpoint, options);
+    if ("status" in admission) {
+        res.writeHead(admission.status, { "content-type": "text/plain; charset=utf-8" });
+        res.end(admission.text + "\n");
+        return;
+    }
+    // The listener sees the request as a backend behind agentmesh-node would: the
+    // path relative to the service, the verified caller, never the biscuit.
+    // X-Peer-Id is set, not added, so an inbound value cannot pose as the
+    // verified peer.
+    req.url = admission.path;
+    delete req.headers[HEADER_MESH_BISCUIT];
+    req.headers[HEADER_PEER_ID] = remotePeer;
+    if (admission.noTrailingSlash) {
+        req.headers[HEADER_MESH_NO_TRAILING_SLASH] = "true";
+    }
+    else {
+        delete req.headers[HEADER_MESH_NO_TRAILING_SLASH];
+    }
+    listener(req, res);
+}
+/**
+ * Server side of /libp2p-http on Node: a listener target is served by Node's
+ * HTTP server on the stream, any other by the runtime-neutral ingress.
+ */
+export function nodeIngressHandler(endpoint, options) {
+    if (!("listener" in endpoint.target)) {
+        return httpIngressHandler(endpoint, options);
+    }
+    const listener = endpoint.target.listener;
+    const server = http.createServer({ keepAlive: false }, (req, res) => {
+        void serveListener(req, res, endpoint, listener, options).catch((err) => {
+            if (!res.headersSent) {
+                res.writeHead(500, { "content-type": "text/plain" });
+            }
+            res.end(`ingress error: ${err instanceof Error ? err.message : String(err)}\n`);
+        });
+    });
+    server.headersTimeout = AUTH_HANDSHAKE_TIMEOUT_MS;
+    return (stream, connection) => {
+        server.emit("connection", streamToNodeDuplex(stream, connection.remotePeer.toString()));
+    };
+}

package/dist/libp2p-http.d.ts

@@ -0,0 +1,165 @@
+import type { Connection, StreamHandler } from "@libp2p/interface";
+import { type ProviderAuthorizerOptions } from "./authorizer.ts";
+import type { VerifiedBiscuit } from "./biscuit.ts";
+/** go-libp2p-http's protocol: plain HTTP/1.1 on a stream, one request per stream. */
+export declare const HTTP_PROTOCOL = "/libp2p-http";
+/** Headers of the mesh HTTP datapath (api/network.go). */
+export declare const HEADER_MESH_BISCUIT = "x-mesh-biscuit";
+export declare const HEADER_PEER_ID = "x-peer-id";
+export declare const HEADER_MESH_NO_TRAILING_SLASH = "x-mesh-no-trailing-slash";
+/** Options for libp2p.handle() so the agent is reachable over relayed connections. */
+export declare const HTTP_HANDLER_OPTIONS: {
+    runOnLimitedConnection: boolean;
+};
+/** The service name an agent answers under unless it picks another. */
+export declare const DEFAULT_A2A_NAME = "agent";
+/**
+ * The path prefix of a mesh URL, http://mesh/mesh/<peer-id>/<type>/<name>/<path>:
+ * the shape of agentmesh-node's egress proxy and of an agent card rewritten for the
+ * mesh, by agentmesh-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 declare const MESH_PATH_PREFIX = "/mesh/";
+/** The well-known agent card location (A2A spec / RFC 8615). */
+export declare const AGENT_CARD_PATH = ".well-known/agent-card.json";
+/** Largest request body the ingress reads whole for a handler or url target. */
+export declare const MAX_INGRESS_BODY_BYTES: number;
+/** A fetch-style handler in this process. */
+export type HTTPHandler = (request: Request, caller: VerifiedBiscuit) => Promise<Response> | Response;
+/**
+ * A request listener of the runtime's own HTTP server, such as an Express
+ * app with the A2A SDK's handlers mounted. On Node it is
+ * (req: http.IncomingMessage, res: http.ServerResponse) => void, served by
+ * libp2p-http-node.ts; a browser has no such server and answers 501.
+ */
+export type NodeRequestListener = (req: any, res: any) => void;
+/**
+ * This member's agent as other members reach it: `a2a://<name>`, answered by
+ * exactly one of url (an A2A server beside this process), handler or
+ * listener (in this process). Authorized requests arrive with the biscuit
+ * header stripped, X-Peer-Id naming the verified caller and the path
+ * relative to /a2a/<name>, as agentmesh-node forwards them. The endpoint is not
+ * announced anywhere; a caller reaches it by peer ID.
+ */
+export interface A2AEndpointSpec {
+    name?: string;
+    url?: string;
+    handler?: HTTPHandler;
+    listener?: NodeRequestListener;
+}
+export interface A2AEndpoint {
+    name: string;
+    service: string;
+    target: {
+        url: string;
+    } | {
+        handler: HTTPHandler;
+    } | {
+        listener: NodeRequestListener;
+    };
+}
+export declare function a2aEndpoint(spec: A2AEndpointSpec): A2AEndpoint;
+export interface ProviderOptions extends ProviderAuthorizerOptions {
+    /** Peers the control plane has banned; refused before their token is looked at. */
+    isBanned?(peerId: string): boolean;
+    /** Called after a caller is authorized, e.g. for the session's admitted set. */
+    onAuthorized?(peerId: string, verified: VerifiedBiscuit, targetService: string): void;
+}
+/** What the ingress looks at before anything reaches the agent. */
+export interface IngressRequest {
+    /** The request method as it came off the wire. */
+    method: string;
+    /** The request target as it came off the wire, path and query. */
+    target: string;
+    headers: Headers;
+    remotePeer: string;
+}
+/** A refusal, with the text the caller gets. */
+export interface IngressRefusal {
+    status: number;
+    text: string;
+}
+/** An authorized request for the endpoint, with what the agent may see. */
+export interface IngressAdmission {
+    verified: VerifiedBiscuit;
+    /** The path relative to the service, query included. */
+    path: string;
+    noTrailingSlash: boolean;
+}
+/**
+ * Server-side admission of /libp2p-http, as agentmesh-node's StartIngressServer:
+ * the path is /<type>/<name>[/<upstream>], the caller's biscuit is
+ * X-Mesh-Biscuit, and the request is authorized for <type>://<name> before
+ * anything is forwarded. Only the agent's own endpoint is answered; anything
+ * else is 404 after authorization, so an unauthorized caller learns nothing
+ * about it.
+ */
+export declare function admitIngress(req: IngressRequest, endpoint: A2AEndpoint, options: ProviderOptions): Promise<IngressRefusal | IngressAdmission>;
+/**
+ * The headers the agent sees: the request's own, less the datapath's, with
+ * X-Peer-Id set (not added) to the verified caller so an inbound value
+ * cannot pose as the peer.
+ */
+export declare function agentHeaders(inbound: Headers, remotePeer: string, noTrailingSlash: boolean): Headers;
+/** A plain-text refusal, as agentmesh-node's ingress writes one. */
+export declare function refusalResponse(refusal: IngressRefusal): Response;
+/**
+ * Server side of /libp2p-http for an endpoint answered by a handler in this
+ * process or an A2A server at a URL. One request per stream; the stream is
+ * closed once the response has been written.
+ */
+export declare function httpIngressHandler(endpoint: A2AEndpoint, options: ProviderOptions): StreamHandler;
+/** The request target for a service on a peer: /<type>/<name>/<path>. */
+export declare function meshHTTPTarget(targetService: string, path?: string): string;
+/**
+ * The URL a fetch bound to a session (session.fetch()) takes for a service
+ * on a peer: http://mesh/mesh/<peer-id>/<type>/<name>/<path>.
+ */
+export declare function meshURL(peerId: string, targetService: string, path?: string): string;
+/** (peer ID, request target) of a mesh URL; the target is what the peer's ingress takes. */
+export declare function splitMeshURL(url: URL): {
+    peerId: string;
+    target: string;
+};
+/**
+ * An agent card rebuilt for the mesh, as agentmesh-node's egress proxy serves it:
+ * HTTP interfaces resolve under base (meshInterfaceURL), gRPC ones go, signatures no longer match.
+ * Streaming stays as declared, this transport streams. Throws when no interface remains.
+ */
+export declare function rewriteAgentCard(card: unknown, base: string): Record<string, unknown>;
+/**
+ * The mesh URL of one agent interface, as agentmesh-node resolves it. The
+ * provider's node names an interface it can reach by a reference relative to
+ * the service root ("invoke", "a2a/rest", "" for the root), which resolves
+ * under base; anything else maps to base itself. A reference that could leave
+ * the service (a dot segment, a rooted path, a scheme or a host) also maps to
+ * base: a provider must not be able to point the caller at another path on
+ * this node. Mirrors Go's url.Parse and URL.EscapedPath for the parts it reads.
+ */
+export declare function meshInterfaceURL(base: string, raw: string): string;
+export interface HTTPStreamOptions {
+    /** Bounds the whole exchange; without one, the response headers must arrive within a minute and the body is unbounded. */
+    signal?: AbortSignal;
+}
+/**
+ * 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-Mesh-Biscuit. Resolves once the response headers are in; the body streams
+ * after, so an SSE response is consumed as the peer sends it. An agent card
+ * is served rewritten for the mesh (rewriteAgentCard), as agentmesh-node serves one.
+ */
+export declare function fetchOverStream(conn: Connection, biscuit: Uint8Array, request: Request, options?: HTTPStreamOptions): Promise<Response>;
+export interface HTTPRequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: Uint8Array | string;
+    signal?: AbortSignal;
+}
+export interface HTTPResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: Uint8Array;
+    text(): string;
+}
+/** One request to /<type>/<name>/<path> on a peer, body read whole. */
+export declare function httpRequestOverStream(conn: Connection, biscuit: Uint8Array, targetService: string, path: string, options?: HTTPRequestOptions): Promise<HTTPResponse>;