nexus-ai-pro 2.15.1 → 2.16.0

package/API_STABILITY.md

@@ -41,6 +41,21 @@ Both are covered by this policy:
 Deep imports into `dist`, `dist-cjs`, or `src` are not supported. Import only from `nexus-ai-pro` or
 one of its explicit subpaths.
 
+## 2.16 stage (2.16.0)
+
+Everything 2.16 adds is stable from the start and additive, unless this section says otherwise.
+
+New and stable:
+- `nexus-ai-pro/protocols/a2a/grpc`: `a2aGrpcService()`, `a2aGrpcClient()`, `A2aGrpcService`,
+  `A2aGrpcServiceOptions`, `A2aGrpcClient`, and `A2aGrpcClientOptions`;
+- in `nexus-ai-pro/protocols/a2a`: the HTTP+JSON routes, `A2aServerOptions.bindings` and
+  `interfaces`, `A2aHandler.call()`, `card`, and `authenticate()`, `A2aBinding`, `A2aCallContext`,
+  `A2aCallOutcome`, `A2aErrorStatus`, `a2aErrorStatus()`, `a2aErrorCode()`,
+  `A2aClientOptions.binding`, `A2aPushOptions.text`, and `A2aPushNotificationConfig.authentication`.
+
+The routes, the gRPC service, and their errors follow A2A 1.0's bindings: a change the specification
+makes in a later version comes with that version, behind `A2A_PROTOCOL_VERSION`.
+
 ## 2.15 stage (2.15.0)
 
 Everything 2.15 adds is stable from the start and additive, unless this section says otherwise.

package/CHANGELOG.md

@@ -4,6 +4,36 @@ Notable changes to this project are recorded here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+## [2.16.0] - 2026-10-20
+
+A2A on all three of its bindings over one set of tasks, and webhooks told the answer as it is written.
+
+### Added
+
+- **A2A over HTTP+JSON and gRPC.** `a2aHandler()` serves the protocol's HTTP+JSON binding beside
+  JSON-RPC, at routes under the card's URL, its errors AIP-193's JSON with A2A's `ErrorInfo` reason.
+  `a2aGrpcService()`, on the new `nexus-ai-pro/protocols/a2a/grpc`, serves the gRPC binding,
+  `lf.a2a.v1.A2AService`, over `node:http2` with no dependency. The card names each binding served
+  (`bindings`, `interfaces`). All three run through `A2aHandler.call()` over one task store, so a
+  caller on any binding continues, reads, cancels, or follows a task another started, and reads the
+  same history.
+- **Clients on every binding.** `a2aClient({ binding: 'HTTP+JSON' })` calls the HTTP+JSON binding, and
+  `a2aGrpcClient()` the gRPC one, with every method `a2aClient()` has. An error on any binding raises
+  an `A2aError` with A2A's code; `a2aErrorStatus()` and `a2aErrorCode()` map a code to its HTTP
+  status, gRPC status, and reason, and back.
+- **A webhook told the answer as it is written.** `pushNotifications.text` pushes each piece of
+  streamed text to a task's webhooks, the same pieces a stream sends, before the state that follows
+  them; `text: { everyMs }` gathers the pieces into fewer deliveries. A push config's
+  `authentication` is sent as each delivery's `Authorization` header.
+- Push configs take protocol 1.0's flat shape on every binding, and JSON-RPC answers both it and the
+  drafts' nested one; `ListTaskPushNotificationConfigs` is answered under its 1.0 name too.
+
+### Changed
+
+- The nightly interoperability check drives `@a2a-js/sdk` over each of the three bindings, and a
+  task across them. It drives `@agentclientprotocol/sdk` 2.0, which dropped
+  `ClientSideConnection`, through its new connection API, and 1.x as before.
+
 ## [2.15.1] - 2026-10-19
 
 A test that could fail by chance, made exact. The package is unchanged from 2.15.0.
@@ -3021,7 +3051,8 @@ shared policy vocabulary is in place for a future release that revisits this.
 - URL fetching rejects unsafe private-network targets and limits response reads.
 - CLI and audit findings no longer disclose detected secret values.
 
-[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.15.1...HEAD
+[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.16.0...HEAD
+[2.16.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.15.1...v2.16.0
 [2.15.1]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.15.0...v2.15.1
 [2.15.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.14.0...v2.15.0
 [2.14.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.13.0...v2.14.0

package/README.md

@@ -321,12 +321,16 @@ Shipped so far:
 - 2.15 a compatibility record for community adapters: `nexus adapters verify` seals the contract an
   adapter passed, against which release, with its benchmark; `nexus adapters recheck` turns a listed
   adapter red before a release that would break it; and one
-  [page](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/COMPATIBILITY.md) lists them.
+  [page](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/COMPATIBILITY.md) lists them;
+- 2.16 A2A over every binding: one agent served over JSON-RPC, HTTP+JSON, and gRPC from one task
+  store, so a caller on any binding continues a task another started, and webhooks told the answer
+  as it is written.
 
 Upgrading from 1.x: `npx nexus migrate src --write` moves your imports, and
 [MIGRATING.md](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/MIGRATING.md) covers the rest.
-Next, 2.16 serves A2A over its HTTP+JSON and gRPC bindings beside JSON-RPC, one task store behind
-all three, and lets a push webhook receive each piece of streamed text. Pinecone, images, the Gemini
+Next, 2.17 connects the MCP servers an editor gives an ACP agent over SSE as well as stdio and HTTP,
+and reads what their tools declare they do, so a permission policy covers them without a rule for
+each. Pinecone, images, the Gemini
 embedding batch tier, media understanding, video, Gemini Live, SIP, and both phone providers
 graduate once the live workflow passes against each. The
 [roadmap](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/ROADMAP.md) lists what comes after, in the order

package/dist/protocols/a2a-grpc.d.ts

@@ -0,0 +1,63 @@
+/**
+ * A2A's gRPC binding: the service `lf.a2a.v1.A2AService` of protocol 1.0, served over the same
+ * `a2aHandler()` as its JSON-RPC and HTTP+JSON bindings, and so over the same tasks, and a client that
+ * calls an agent over it. Over HTTP/2 from `node:http2`, with no dependency.
+ *
+ * ```ts
+ * const handler = a2aHandler(agent, { card, interfaces: [{ url: 'agents.example.com:50051', protocolBinding: 'GRPC' }] });
+ * const grpc = a2aGrpcService(handler);
+ * await grpc.listen(50051);
+ * ```
+ */
+import { type Http2Server, type IncomingHttpHeaders, type ServerHttp2Stream } from 'node:http2';
+import { type A2aClient, type A2aClientOptions, type A2aHandler } from './a2a.js';
+/** Options for `a2aGrpcService()`. */
+export interface A2aGrpcServiceOptions {
+    /** Largest request message taken, in bytes. Defaults to 4 MiB, gRPC's own default. */
+    maxMessageBytes?: number;
+}
+/** The gRPC binding of one A2A handler. */
+export interface A2aGrpcService {
+    /**
+     * Answers one HTTP/2 stream: give it each stream of a server of your own, such as one over TLS,
+     * as `server.on('stream', service.handle)`.
+     */
+    handle(stream: ServerHttp2Stream, headers: IncomingHttpHeaders): void;
+    /**
+     * Starts a server over plain HTTP/2 on `port`, 0 for any, on `host`: for a server behind a proxy
+     * that ends TLS, and for tests. Resolves with the address to list on the card, `host:port`. Its
+     * `close()` stops taking calls, tells each connected client to go, and resolves once the calls in
+     * flight finish.
+     */
+    listen(port?: number, host?: string): Promise<{
+        url: string;
+        port: number;
+        server: Http2Server;
+        close(): Promise<void>;
+    }>;
+}
+/**
+ * The gRPC binding over an `a2aHandler()`: each method of `lf.a2a.v1.A2AService`, its message read as
+ * the JSON the handler takes and its answer written back, a stream as a server-streaming call, and an
+ * error as a gRPC status with A2A's `ErrorInfo` in `grpc-status-details-bin`. The caller is read by the
+ * handler's own `principal`, from a `Request` with the call's metadata as its headers.
+ */
+export declare function a2aGrpcService(handler: A2aHandler, options?: A2aGrpcServiceOptions): A2aGrpcService;
+/** Options for `a2aGrpcClient()`. */
+export interface A2aGrpcClientOptions extends Omit<A2aClientOptions, 'binding' | 'url'> {
+    /** Where the agent's gRPC service is: `host:port`, as its card lists it, or an `http://` or `https://` URL. */
+    url: string;
+    /** Where its card is, for `card()`. Without it, `card()` reads the extended card. */
+    cardUrl?: string;
+}
+/** A client for an A2A agent over gRPC, with `close()` for its connection. */
+export interface A2aGrpcClient extends A2aClient {
+    /** Closes the HTTP/2 connection. */
+    close(): Promise<void>;
+}
+/**
+ * A client for one A2A agent over its gRPC binding: the same methods as `a2aClient()`, each a call of
+ * `lf.a2a.v1.A2AService` over one HTTP/2 connection, a gRPC error raised as an `A2aError` with the
+ * protocol's code. Plain HTTP/2 for `host:port` and `http://`; TLS for `https://`.
+ */
+export declare function a2aGrpcClient(options: A2aGrpcClientOptions): A2aGrpcClient;

package/dist/protocols/a2a-grpc.js

@@ -0,0 +1,374 @@
+import http2 from 'node:http2';
+import { gunzipSync, inflateSync } from 'node:zlib';
+import { A2A_PROTOCOL_VERSION, A2aError, a2aErrorCode, a2aErrorStatus, } from './a2a.js';
+import { A2A_GRPC_METHODS, A2A_GRPC_SERVICE, a2aStatusReason, decodeA2a, encodeA2a, encodeA2aStatus, } from './a2a-proto.js';
+import { protocolId } from './shared.js';
+const GRPC_CODES = {
+    OK: 0,
+    CANCELLED: 1,
+    UNKNOWN: 2,
+    INVALID_ARGUMENT: 3,
+    DEADLINE_EXCEEDED: 4,
+    NOT_FOUND: 5,
+    ALREADY_EXISTS: 6,
+    PERMISSION_DENIED: 7,
+    RESOURCE_EXHAUSTED: 8,
+    FAILED_PRECONDITION: 9,
+    ABORTED: 10,
+    OUT_OF_RANGE: 11,
+    UNIMPLEMENTED: 12,
+    INTERNAL: 13,
+    UNAVAILABLE: 14,
+    DATA_LOSS: 15,
+    UNAUTHENTICATED: 16,
+};
+export function a2aGrpcService(handler, options = {}) {
+    const maxBytes = options.maxMessageBytes ?? 4 * 1024 * 1024;
+    const handle = (stream, headers) => {
+        const path = String(headers[':path'] ?? '');
+        const method = path.startsWith(`/${A2A_GRPC_SERVICE}/`) ? path.slice(A2A_GRPC_SERVICE.length + 2) : '';
+        const shape = A2A_GRPC_METHODS[method];
+        const contentType = String(headers['content-type'] ?? '');
+        if (!contentType.startsWith('application/grpc')) {
+            stream.respond({ ':status': 415 }, { endStream: true });
+            return;
+        }
+        if (!shape) {
+            fail(stream, GRPC_CODES.UNIMPLEMENTED, `Method ${path} is not part of ${A2A_GRPC_SERVICE}`);
+            return;
+        }
+        const version = headers['a2a-version'];
+        if (typeof version === 'string' && !version.startsWith('1.')) {
+            failA2a(stream, -32009, `This agent speaks A2A ${A2A_PROTOCOL_VERSION}, not ${version}`);
+            return;
+        }
+        const controller = new AbortController();
+        const timeout = deadline(headers['grpc-timeout']);
+        const timer = timeout === undefined ? undefined : setTimeout(() => controller.abort(new Error('deadline exceeded')), timeout);
+        stream.on('close', () => {
+            if (timer)
+                clearTimeout(timer);
+            controller.abort(new Error('The caller went away'));
+        });
+        const chunks = [];
+        let size = 0;
+        stream.on('data', (chunk) => {
+            size += chunk.length;
+            if (size <= maxBytes + 5)
+                chunks.push(chunk);
+        });
+        stream.on('end', () => {
+            void (async () => {
+                if (size > maxBytes + 5) {
+                    return fail(stream, GRPC_CODES.RESOURCE_EXHAUSTED, `The request is larger than ${maxBytes} bytes`);
+                }
+                let params;
+                try {
+                    const [message] = frames(Buffer.concat(chunks), headers['grpc-encoding']);
+                    params = decodeA2a(shape.request, message ?? new Uint8Array());
+                }
+                catch (error) {
+                    return fail(stream, GRPC_CODES.INVALID_ARGUMENT, error.message);
+                }
+                const request = new Request(`http://grpc.invalid${path}`, { method: 'POST', headers: metadataOf(headers) });
+                const principal = await handler.authenticate(request);
+                const outcome = await handler.call(method, params, {
+                    ...(principal ? { principal } : {}),
+                    signal: controller.signal,
+                    binding: 'GRPC',
+                });
+                if ('error' in outcome)
+                    return failA2a(stream, outcome.error.code, outcome.error.message);
+                if (stream.destroyed)
+                    return;
+                stream.respond({ ':status': 200, 'content-type': 'application/grpc+proto' }, { waitForTrailers: true });
+                let trailers = { 'grpc-status': '0' };
+                stream.on('wantTrailers', () => stream.sendTrailers(trailers));
+                if ('events' in outcome) {
+                    const reader = outcome.events.getReader();
+                    try {
+                        for (;;) {
+                            const { value, done } = await reader.read();
+                            if (done || stream.destroyed)
+                                break;
+                            stream.write(frame(encodeA2a(shape.response, value)));
+                        }
+                    }
+                    catch (error) {
+                        trailers = errorTrailers(-32603, error.message);
+                    }
+                    finally {
+                        if (stream.destroyed)
+                            void reader.cancel();
+                    }
+                }
+                else {
+                    stream.write(frame(encodeA2a(shape.response, outcome.result ?? {})));
+                }
+                if (!stream.destroyed)
+                    stream.end();
+            })().catch((error) => {
+                if (!stream.headersSent)
+                    fail(stream, GRPC_CODES.INTERNAL, error.message);
+                else
+                    stream.destroy(error);
+            });
+        });
+    };
+    return {
+        handle,
+        async listen(port = 0, host = '127.0.0.1') {
+            const server = http2.createServer();
+            server.on('stream', handle);
+            const sessions = new Set();
+            server.on('session', (session) => {
+                sessions.add(session);
+                session.on('close', () => sessions.delete(session));
+            });
+            await new Promise((resolve) => server.listen(port, host, resolve));
+            const address = server.address();
+            return {
+                url: `${host}:${address.port}`,
+                port: address.port,
+                server,
+                close: () => new Promise((resolve) => {
+                    server.close(() => resolve());
+                    for (const session of sessions)
+                        session.close();
+                }),
+            };
+        },
+    };
+}
+function fail(stream, code, message, details) {
+    if (stream.destroyed || stream.headersSent)
+        return;
+    stream.respond({
+        ':status': 200,
+        'content-type': 'application/grpc+proto',
+        'grpc-status': String(code),
+        'grpc-message': grpcMessage(message),
+        ...(details ? { 'grpc-status-details-bin': Buffer.from(details).toString('base64').replace(/=+$/, '') } : {}),
+    }, { endStream: true });
+}
+function failA2a(stream, code, message) {
+    const status = a2aErrorStatus(code);
+    const grpc = GRPC_CODES[status.grpcStatus] ?? GRPC_CODES.INTERNAL;
+    fail(stream, grpc, message, encodeA2aStatus(grpc, message, status.reason));
+}
+function errorTrailers(code, message) {
+    const status = a2aErrorStatus(code);
+    const grpc = GRPC_CODES[status.grpcStatus] ?? GRPC_CODES.INTERNAL;
+    return {
+        'grpc-status': String(grpc),
+        'grpc-message': grpcMessage(message),
+        'grpc-status-details-bin': Buffer.from(encodeA2aStatus(grpc, message, status.reason))
+            .toString('base64')
+            .replace(/=+$/, ''),
+    };
+}
+function frame(message) {
+    const out = new Uint8Array(5 + message.length);
+    new DataView(out.buffer).setUint32(1, message.length);
+    out.set(message, 5);
+    return out;
+}
+function frames(body, encoding) {
+    const out = [];
+    let offset = 0;
+    while (offset + 5 <= body.length) {
+        const compressed = body[offset] === 1;
+        const length = body.readUInt32BE(offset + 1);
+        let message = body.subarray(offset + 5, offset + 5 + length);
+        if (message.length < length)
+            throw new Error('A gRPC message ended early');
+        if (compressed) {
+            const name = String(encoding ?? 'identity');
+            if (name === 'gzip')
+                message = gunzipSync(message);
+            else if (name === 'deflate')
+                message = inflateSync(message);
+            else
+                throw new Error(`A gRPC message compressed with ${name} cannot be read`);
+        }
+        out.push(message);
+        offset += 5 + length;
+    }
+    return out;
+}
+function deadline(value) {
+    const match = typeof value === 'string' ? /^(\d+)([HMSmun])$/.exec(value) : null;
+    if (!match)
+        return undefined;
+    const amount = Number(match[1]);
+    const unit = { H: 3_600_000, M: 60_000, S: 1_000, m: 1, u: 0.001, n: 0.000001 }[match[2]];
+    return Math.max(0, amount * unit);
+}
+function grpcMessage(message) {
+    let out = '';
+    for (const byte of new TextEncoder().encode(message)) {
+        out +=
+            byte >= 0x20 && byte <= 0x7e && byte !== 0x25
+                ? String.fromCharCode(byte)
+                : `%${byte.toString(16).toUpperCase().padStart(2, '0')}`;
+    }
+    return out;
+}
+function decodeGrpcMessage(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function metadataOf(headers) {
+    const out = new Headers();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.startsWith(':') || value === undefined || name.endsWith('-bin'))
+            continue;
+        out.set(name, Array.isArray(value) ? value.join(', ') : String(value));
+    }
+    return out;
+}
+export function a2aGrpcClient(options) {
+    const authority = /^https?:\/\//.test(options.url) ? options.url : `http://${options.url}`;
+    let session;
+    let active = 0;
+    const connect = () => {
+        if (!session || session.closed || session.destroyed) {
+            session = http2.connect(authority);
+            session.on('error', () => undefined);
+            session.unref();
+        }
+        return session;
+    };
+    async function* invoke(method, params, signal) {
+        const shape = A2A_GRPC_METHODS[method];
+        const connection = connect();
+        active += 1;
+        connection.ref();
+        const request = connection.request({
+            ':method': 'POST',
+            ':path': `/${A2A_GRPC_SERVICE}/${method}`,
+            'content-type': 'application/grpc+proto',
+            te: 'trailers',
+            'a2a-version': A2A_PROTOCOL_VERSION,
+            ...Object.fromEntries(Object.entries(options.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value])),
+        });
+        const abort = () => request.close(http2.constants.NGHTTP2_CANCEL);
+        signal?.addEventListener('abort', abort, { once: true });
+        request.end(frame(encodeA2a(shape.request, params)));
+        let status = {};
+        request.on('response', (headers) => {
+            if (headers['grpc-status'] !== undefined)
+                status = headers;
+        });
+        request.on('trailers', (trailers) => {
+            status = trailers;
+        });
+        let buffer = Buffer.alloc(0);
+        try {
+            for await (const chunk of request) {
+                buffer = Buffer.concat([buffer, chunk]);
+                while (buffer.length >= 5) {
+                    const length = buffer.readUInt32BE(1);
+                    if (buffer.length < 5 + length)
+                        break;
+                    yield decodeA2a(shape.response, buffer.subarray(5, 5 + length));
+                    buffer = buffer.subarray(5 + length);
+                }
+            }
+            const code = Number(status['grpc-status'] ?? 2);
+            if (code !== 0) {
+                const details = status['grpc-status-details-bin'];
+                const info = typeof details === 'string' ? a2aStatusReason(Buffer.from(details, 'base64')) : {};
+                const message = info.message ?? decodeGrpcMessage(String(status['grpc-message'] ?? `gRPC status ${code}`));
+                throw new A2aError(a2aErrorCode(info.reason, code === 5 ? -32001 : -32603), message, { grpcStatus: code });
+            }
+        }
+        finally {
+            signal?.removeEventListener('abort', abort);
+            active -= 1;
+            if (active === 0)
+                connection.unref();
+        }
+    }
+    const unary = async (method, params, signal) => {
+        let answer;
+        for await (const message of invoke(method, params, signal))
+            answer = message;
+        return (answer ?? {});
+    };
+    const message = (text, send) => ({
+        messageId: protocolId('message'),
+        role: 'ROLE_USER',
+        parts: [{ text }, ...(send.data === undefined ? [] : [{ data: send.data }])],
+        ...(send.contextId ? { contextId: send.contextId } : {}),
+        ...(send.taskId ? { taskId: send.taskId } : {}),
+    });
+    const configuration = (send) => ({
+        returnImmediately: send.returnImmediately === true,
+        ...(send.push ? { taskPushNotificationConfig: send.push } : {}),
+    });
+    const pushConfig = (answer) => {
+        const { taskId: _taskId, tenant: _tenant, ...config } = answer;
+        return config;
+    };
+    const card = async () => {
+        if (!options.cardUrl)
+            return unary('GetExtendedAgentCard', {});
+        const response = await (options.fetch ?? globalThis.fetch)(options.cardUrl, {
+            headers: { accept: 'application/json', ...options.headers },
+        });
+        if (!response.ok)
+            throw new A2aError(response.status, `The agent card answered ${response.status}`);
+        return (await response.json());
+    };
+    return {
+        card,
+        extendedCard: () => unary('GetExtendedAgentCard', {}),
+        async send(text, send = {}) {
+            const result = await unary('SendMessage', { message: message(text, send), configuration: configuration(send) }, send.signal);
+            if (result.task)
+                return result.task;
+            const reply = result.message;
+            return {
+                id: reply?.taskId ?? '',
+                contextId: reply?.contextId ?? send.contextId ?? '',
+                status: { state: 'TASK_STATE_COMPLETED', ...(reply ? { message: reply } : {}) },
+                artifacts: [{ artifactId: 'message', parts: reply?.parts ?? [] }],
+            };
+        },
+        async *stream(text, send = {}) {
+            for await (const event of invoke('SendStreamingMessage', { message: message(text, send), ...(send.push ? { configuration: configuration(send) } : {}) }, send.signal)) {
+                yield event;
+            }
+        },
+        getTask: (taskId, historyLength) => unary('GetTask', { id: taskId, ...(historyLength ? { historyLength } : {}) }),
+        listTasks: (list = {}) => unary('ListTasks', { ...list }),
+        async *subscribe(taskId, subscribe = {}) {
+            for await (const event of invoke('SubscribeToTask', { id: taskId }, subscribe.signal)) {
+                yield event;
+            }
+        },
+        cancel: (taskId) => unary('CancelTask', { id: taskId }),
+        async setPushNotification(taskId, config) {
+            return pushConfig(await unary('CreateTaskPushNotificationConfig', { ...config, taskId }));
+        },
+        async listPushNotifications(taskId) {
+            const result = await unary('ListTaskPushNotificationConfigs', {
+                taskId,
+            });
+            return (result.configs ?? []).map(pushConfig);
+        },
+        async deletePushNotification(taskId, configId) {
+            await unary('DeleteTaskPushNotificationConfig', { taskId, id: configId });
+        },
+        close: () => new Promise((resolve) => {
+            if (!session || session.closed)
+                return resolve();
+            session.close(() => resolve());
+        }),
+    };
+}

package/dist/protocols/a2a-proto.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A2A's messages in Protocol Buffers, as `specification/a2a.proto` of protocol 1.0 numbers them
+ * (package `lf.a2a.v1`): each turned into, and read from, the JSON the other bindings carry, so the
+ * gRPC binding calls the same methods with the same params. With `google.protobuf.Struct`, `Value`,
+ * `Timestamp`, and `google.rpc.Status`. Fields the agent never sends, such as a card's security
+ * schemes, are read past and not written.
+ */
+/** Each method of `lf.a2a.v1.A2AService`: what it takes, what it answers, and whether it streams. */
+export declare const A2A_GRPC_METHODS: Readonly<Record<string, {
+    request: string;
+    response: string;
+    stream?: boolean;
+}>>;
+/** The service's path prefix: `/lf.a2a.v1.A2AService/<method>`. */
+export declare const A2A_GRPC_SERVICE = "lf.a2a.v1.A2AService";
+/** Writes the JSON of a message as its Protocol Buffers bytes. */
+export declare function encodeA2a(type: string, value: unknown): Uint8Array;
+/** Reads a message's bytes as its JSON. */
+export declare function decodeA2a(type: string, bytes: Uint8Array): Record<string, unknown>;
+/** A `google.rpc.Status` with A2A's `ErrorInfo`, as `grpc-status-details-bin` carries it. */
+export declare function encodeA2aStatus(code: number, message: string, reason: string): Uint8Array;
+/** The `ErrorInfo` reason of a `google.rpc.Status`, when it has one. */
+export declare function a2aStatusReason(bytes: Uint8Array): {
+    message?: string;
+    reason?: string;
+};