starpc 0.49.18 → 0.50.0

package/dist/srpc/call-receipt.test.js

@@ -0,0 +1,375 @@
+/// <reference lib="es2024.promise" />
+import { describe, expect, it } from 'vitest';
+import { pushable } from 'it-pushable';
+import { EchoMsg } from '../echo/echo.pb.js';
+import { Client } from './client.js';
+import { ClientRPC } from './client-rpc.js';
+import { Server } from './server.js';
+import { CallReceipt } from './call-receipt.js';
+import { Packet, TerminalKind } from './rpcproto.pb.js';
+import { ServerRPC } from './server-rpc.js';
+const response = new Uint8Array([1, 2, 3]);
+describe('generated service compatibility', () => {
+    it('accepts plain abort signals and terminal-capable handlers', async () => {
+        const server = {
+            Echo: async (request, invocation) => {
+                void invocation;
+                return request;
+            },
+        };
+        const request = EchoMsg.create({ body: 'compatibility' });
+        const signal = new AbortController().signal;
+        await expect(server.Echo(request, signal)).resolves.toEqual(request);
+    });
+});
+describe('held unary receipt', () => {
+    it('waits for a server completion acknowledgment', async () => {
+        const sent = [];
+        const terminal = Promise.withResolvers();
+        const client = new Client(async () => ({
+            source: responseSource(terminal.promise),
+            sink: async (source) => {
+                for await (const data of source) {
+                    const packet = Packet.fromBinary(data);
+                    sent.push(packet);
+                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
+                        terminal.resolve();
+                    }
+                }
+            },
+        }));
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        const commit = held.receipt.commit();
+        expect(held.receipt.settled).toBe(true);
+        await expect(commit).resolves.toBeUndefined();
+        const terminalPackets = sent.filter((packet) => {
+            const body = packet.body;
+            return (body?.case === 'callCancel' ||
+                (body?.case === 'callData' && body.value.complete));
+        });
+        expect(terminalPackets).toHaveLength(1);
+        expect(terminalPackets[0]?.body?.case).toBe('callData');
+        await expect(held.receipt.done).resolves.toBeUndefined();
+    });
+    it('commits through a real TypeScript server', async () => {
+        const terminal = Promise.withResolvers();
+        const server = new Server(async () => {
+            return async (_source, dataSink, invocation) => {
+                await dataSink((async function* () {
+                    yield response;
+                    if (!invocation) {
+                        throw new Error('missing invocation');
+                    }
+                    terminal.resolve(await invocation.waitTerminal(new AbortController().signal));
+                })());
+            };
+        });
+        const client = new Client(async () => {
+            const clientToServer = pushable({ objectMode: true });
+            const serverToClient = pushable({ objectMode: true });
+            server.handlePacketStream({
+                source: clientToServer,
+                sink: async (source) => {
+                    for await (const packet of source) {
+                        serverToClient.push(packet);
+                    }
+                    serverToClient.end();
+                },
+            });
+            return {
+                source: serverToClient,
+                sink: async (source) => {
+                    for await (const packet of source) {
+                        clientToServer.push(packet);
+                    }
+                    clientToServer.end();
+                },
+            };
+        });
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        await expect(held.receipt.commit()).resolves.toBeUndefined();
+        await expect(terminal.promise).resolves.toBe(TerminalKind.COMMITTED);
+    });
+    it('rejects commit after a bare remote close', async () => {
+        const call = new ClientRPC('test.Service', 'Unary');
+        const iterator = call.rpcDataSource[Symbol.asyncIterator]();
+        await call.handleCallData({
+            data: response,
+            dataIsZero: false,
+            complete: false,
+            error: '',
+        });
+        const first = await iterator.next();
+        expect(first.done).toBe(false);
+        const receipt = new CallReceipt(call, iterator);
+        await call.close();
+        await expect(receipt.commit()).rejects.toThrow();
+        await expect(receipt.done).rejects.toThrow('receipt closed before commit');
+    });
+    it('aborts a held receipt with one cancel packet', async () => {
+        const sent = [];
+        const terminal = Promise.withResolvers();
+        const cancelSeen = Promise.withResolvers();
+        const client = new Client(async () => ({
+            source: responseSource(terminal.promise),
+            sink: async (source) => {
+                for await (const data of source) {
+                    const packet = Packet.fromBinary(data);
+                    sent.push(packet);
+                    if (packet.body?.case === 'callCancel') {
+                        cancelSeen.resolve();
+                    }
+                }
+            },
+        }));
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        await held.receipt.abort();
+        await cancelSeen.promise;
+        const terminalPackets = sent.filter((packet) => packet.body?.case === 'callCancel');
+        expect(terminalPackets).toHaveLength(1);
+        await expect(held.receipt.done).rejects.toThrow();
+    });
+    it('allows exactly one concurrent commit or abort terminal', async () => {
+        const sent = [];
+        const terminal = Promise.withResolvers();
+        const client = new Client(async () => ({
+            source: responseSource(terminal.promise),
+            sink: async (source) => {
+                for await (const data of source) {
+                    const packet = Packet.fromBinary(data);
+                    sent.push(packet);
+                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
+                        terminal.resolve();
+                    }
+                }
+            },
+        }));
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        const results = await Promise.allSettled([
+            held.receipt.commit(),
+            held.receipt.abort(),
+        ]);
+        const terminalPackets = sent.filter((packet) => {
+            const body = packet.body;
+            return (body?.case === 'callCancel' ||
+                (body?.case === 'callData' && body.value.complete));
+        });
+        expect(terminalPackets).toHaveLength(1);
+        expect(results).toHaveLength(2);
+    });
+    it('rejects a trailing response datum instead of committing', async () => {
+        const terminal = Promise.withResolvers();
+        const client = new Client(async () => ({
+            source: (async function* () {
+                yield Packet.toBinary({
+                    body: {
+                        case: 'callData',
+                        value: {
+                            data: response,
+                            dataIsZero: false,
+                            complete: false,
+                            error: '',
+                        },
+                    },
+                });
+                await terminal.promise;
+                yield Packet.toBinary({
+                    body: {
+                        case: 'callData',
+                        value: {
+                            data: new Uint8Array([9]),
+                            dataIsZero: false,
+                            complete: false,
+                            error: '',
+                        },
+                    },
+                });
+            })(),
+            sink: async (source) => {
+                for await (const data of source) {
+                    const packet = Packet.fromBinary(data);
+                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
+                        terminal.resolve();
+                    }
+                }
+            },
+        }));
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        await expect(held.receipt.commit()).rejects.toThrow('unexpected trailing response data');
+    });
+    it('rejects done on a remote terminal error', async () => {
+        const client = new Client(async () => ({
+            source: (async function* () {
+                yield Packet.toBinary({
+                    body: {
+                        case: 'callData',
+                        value: {
+                            data: response,
+                            dataIsZero: false,
+                            complete: false,
+                            error: '',
+                        },
+                    },
+                });
+                yield Packet.toBinary({
+                    body: {
+                        case: 'callData',
+                        value: {
+                            data: new Uint8Array(),
+                            dataIsZero: false,
+                            complete: true,
+                            error: 'remote failure',
+                        },
+                    },
+                });
+            })(),
+            sink: async (source) => {
+                for await (const _data of source) {
+                    void _data;
+                }
+            },
+        }));
+        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
+        await expect(held.receipt.done).rejects.toThrow('remote failure');
+    });
+});
+describe('server invocation terminal', () => {
+    it.each([
+        ['explicit completion', TerminalKind.COMMITTED],
+        ['cancel', TerminalKind.CANCELED],
+        ['transport loss', TerminalKind.TRANSPORT_LOST],
+        ['remote error packet', TerminalKind.TRANSPORT_LOST],
+        ['bare close', TerminalKind.CLOSED],
+        ['remote error packet with completion', TerminalKind.TRANSPORT_LOST],
+    ])('%s is classified distinctly', async (_name, expected) => {
+        const captured = Promise.withResolvers();
+        const owner = new AbortController();
+        const observed = Promise.withResolvers();
+        const rpc = new ServerRPC(async () => {
+            return async (_source, _sink, invocation) => {
+                if (!invocation) {
+                    throw new Error('missing invocation');
+                }
+                captured.resolve(invocation);
+                observed.resolve(await invocation.waitTerminal(owner.signal));
+            };
+        });
+        await rpc.handleCallStart({
+            rpcService: 'test.Service',
+            rpcMethod: 'Unary',
+            data: new Uint8Array(),
+            dataIsZero: true,
+        });
+        const invocation = await captured.promise;
+        if (expected === TerminalKind.COMMITTED) {
+            await rpc.handleCallData({ complete: true });
+        }
+        else if (expected === TerminalKind.CANCELED) {
+            await rpc.handleCallCancel();
+        }
+        else if (expected === TerminalKind.TRANSPORT_LOST) {
+            if (_name === 'remote error packet' ||
+                _name === 'remote error packet with completion') {
+                await rpc.handleCallData({
+                    complete: _name === 'remote error packet with completion',
+                    error: 'remote failure',
+                });
+            }
+            else {
+                await rpc.close(new Error('transport loss'));
+            }
+        }
+        else {
+            await rpc.close();
+        }
+        await expect(observed.promise).resolves.toBe(expected);
+        owner.abort();
+        if (_name === 'remote error packet with completion') {
+            const rpcState = rpc;
+            if (!('remoteCompleted' in rpcState)) {
+                throw new Error('remote completion discriminator is missing');
+            }
+            expect(rpcState.remoteCompleted).toBe(false);
+        }
+        if (expected === TerminalKind.CLOSED ||
+            expected === TerminalKind.TRANSPORT_LOST) {
+            expect(invocation.signal.aborted).toBe(true);
+        }
+    });
+    it.each(['transport loss', 'cancel'])('keeps completion after %s', async (followUp) => {
+        const captured = Promise.withResolvers();
+        const owner = new AbortController();
+        const rpc = new ServerRPC(async () => {
+            return async (_source, _sink, invocation) => {
+                if (!invocation) {
+                    throw new Error('missing invocation');
+                }
+                captured.resolve(invocation);
+                await invocation.waitTerminal(owner.signal);
+            };
+        });
+        await rpc.handleCallStart({
+            rpcService: 'test.Service',
+            rpcMethod: 'Unary',
+            data: new Uint8Array(),
+            dataIsZero: true,
+        });
+        const invocation = await captured.promise;
+        await rpc.handleCallData({ complete: true });
+        if (followUp === 'transport loss') {
+            await rpc.close(new Error('transport loss'));
+        }
+        else {
+            await rpc.handleCallCancel();
+        }
+        await expect(invocation.waitTerminal(owner.signal)).resolves.toBe(TerminalKind.COMMITTED);
+        owner.abort();
+    });
+    it('returns abandoned only for owner cancellation without a remote terminal', async () => {
+        const captured = Promise.withResolvers();
+        const owner = new AbortController();
+        const rpc = new ServerRPC(async () => {
+            return async (_source, _sink, invocation) => {
+                if (!invocation) {
+                    throw new Error('missing invocation');
+                }
+                captured.resolve(invocation);
+                await invocation.waitTerminal(owner.signal);
+            };
+        });
+        await rpc.handleCallStart({
+            rpcService: 'test.Service',
+            rpcMethod: 'Unary',
+            data: new Uint8Array(),
+            dataIsZero: true,
+        });
+        const invocation = await captured.promise;
+        owner.abort();
+        await expect(invocation.waitTerminal(owner.signal)).resolves.toBe(TerminalKind.ABANDONED);
+    });
+});
+async function* responseSource(terminal) {
+    yield Packet.toBinary({
+        body: {
+            case: 'callData',
+            value: {
+                data: response,
+                dataIsZero: false,
+                complete: false,
+                error: '',
+            },
+        },
+    });
+    await terminal;
+    yield Packet.toBinary({
+        body: {
+            case: 'callData',
+            value: {
+                data: new Uint8Array(),
+                dataIsZero: false,
+                complete: true,
+                error: '',
+            },
+        },
+    });
+}

package/dist/srpc/client.d.ts

@@ -1,10 +1,12 @@
 import type { ProtoRpc } from './proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
-export declare class Client implements ProtoRpc {
+import type { HeldCall, ReceiptRpc } from './call-receipt.js';
+export declare class Client implements ProtoRpc, ReceiptRpc {
     private openStreamCtr;
     constructor(openStreamFn?: OpenStreamFunc);
     setOpenStreamFn(openStreamFn?: OpenStreamFunc): void;
     request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    requestWithReceipt(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<HeldCall>;
     clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
     bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;

package/dist/srpc/client.js

@@ -5,6 +5,7 @@ import { ClientRPC } from './client-rpc.js';
 import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource } from './packet.js';
 import { OpenStreamCtr } from './open-stream-ctr.js';
+import { CallReceipt } from './call-receipt.js';
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
     // openStreamCtr contains the OpenStreamFunc.
@@ -27,6 +28,25 @@ export class Client {
         call.close(err);
         throw err;
     }
+    // requestWithReceipt reads one response and retains the call terminal.
+    async requestWithReceipt(service, method, data, abortSignal) {
+        const call = await this.startRpc(service, method, data, abortSignal);
+        const iterator = call.rpcDataSource[Symbol.asyncIterator]();
+        try {
+            const result = await iterator.next();
+            if (result.done) {
+                throw new Error('empty response');
+            }
+            return {
+                response: result.value,
+                receipt: new CallReceipt(call, iterator),
+            };
+        }
+        catch (err) {
+            await call.close(err instanceof Error ? err : new Error('receipt read failed'));
+            throw err;
+        }
+    }
     // clientStreamingRequest starts a client side streaming request.
     async clientStreamingRequest(service, method, data, abortSignal) {
         const call = await this.startRpc(service, method, null, abortSignal);

package/dist/srpc/common-rpc.d.ts

@@ -1,6 +1,5 @@
 import type { Sink, Source } from 'it-stream-types';
-import type { CallData, CallStart } from './rpcproto.pb.js';
-import { Packet } from './rpcproto.pb.js';
+import { Packet, TerminalKind, type CallData, type CallStart } from './rpcproto.pb.js';
 export declare class CommonRPC {
     readonly sink: Sink<Source<Packet>>;
     readonly source: AsyncIterable<Packet>;
@@ -10,12 +9,23 @@ export declare class CommonRPC {
     protected service?: string;
     protected method?: string;
     private closed?;
+    private remoteCompleted;
+    private remoteError?;
+    private remoteSourceClosed;
+    private remoteTerminal?;
+    private readonly invocationController;
+    private readonly terminalPromise;
+    private resolveTerminal;
     private readonly writeDrainAbort;
     constructor();
     get isClosed(): boolean | Error;
+    protected get invocationSignal(): AbortSignal;
+    protected waitTerminal(ownerSignal: AbortSignal): Promise<TerminalKind>;
+    getTerminalKind(): TerminalKind | undefined;
+    private recordRemoteTerminal;
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     private writeCallDataPacket;
-    writeCallCancel(): Promise<void>;
+    writeCallCancel(waitForDrain?: boolean): Promise<void>;
     writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>): Promise<void>;
     protected writePacket(packet: Packet, options?: WritePacketOptions): Promise<void>;
     handleMessage(message: Uint8Array): Promise<void>;

package/dist/srpc/common-rpc.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { Packet } from './rpcproto.pb.js';
+import { Packet, TerminalKind, } from './rpcproto.pb.js';
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js';
 const maxBufferedOutgoingPackets = 1;
 // CommonRPC is common logic between server and client RPCs.
@@ -24,9 +24,25 @@ export class CommonRPC {
     method;
     // closed indicates this rpc has been closed already.
     closed;
+    // remoteCompleted is set only by an explicit remote CallData completion.
+    remoteCompleted = false;
+    // remoteError records a remote error or transport failure.
+    remoteError;
+    // remoteSourceClosed records an incoming source ending without a packet error.
+    remoteSourceClosed = false;
+    // remoteTerminal is the first valid remote terminal.
+    remoteTerminal;
+    // invocationController cancels the server invocation on a remote terminal.
+    invocationController = new AbortController();
+    // terminalPromise resolves when a remote terminal is recorded.
+    terminalPromise;
+    resolveTerminal;
     // writeDrainAbort wakes writers waiting for outbound stream drain on close.
     writeDrainAbort = new AbortController();
     constructor() {
+        const { promise, resolve } = Promise.withResolvers();
+        this.terminalPromise = promise;
+        this.resolveTerminal = resolve;
         this.sink = this._createSink();
         this.source = this._source;
         this.rpcDataSource = this._rpcDataSource;
@@ -35,6 +51,49 @@ export class CommonRPC {
     get isClosed() {
         return this.closed ?? false;
     }
+    // invocationSignal is canceled when the RPC reaches a terminal.
+    get invocationSignal() {
+        return this.invocationController.signal;
+    }
+    // waitTerminal waits for the remote terminal or external owner cancellation.
+    async waitTerminal(ownerSignal) {
+        const { promise: ownerDone, resolve: resolveOwnerDone } = Promise.withResolvers();
+        const onAbort = () => resolveOwnerDone();
+        ownerSignal.addEventListener('abort', onAbort, { once: true });
+        let ownerAborted = ownerSignal.aborted;
+        try {
+            for (;;) {
+                const terminal = this.getTerminalKind();
+                if (terminal !== undefined) {
+                    if (terminal === TerminalKind.CLOSED &&
+                        this.remoteSourceClosed &&
+                        !this.closed) {
+                        await this.close();
+                    }
+                    return terminal;
+                }
+                if (ownerAborted) {
+                    return TerminalKind.ABANDONED;
+                }
+                await Promise.race([this.terminalPromise, ownerDone]);
+                ownerAborted = ownerSignal.aborted;
+            }
+        }
+        finally {
+            ownerSignal.removeEventListener('abort', onAbort);
+        }
+    }
+    // getTerminalKind returns the observed remote terminal, if any.
+    getTerminalKind() {
+        return this.remoteTerminal;
+    }
+    recordRemoteTerminal(kind) {
+        if (this.remoteTerminal !== undefined) {
+            return;
+        }
+        this.remoteTerminal = kind;
+        this.resolveTerminal();
+    }
     // writeCallData writes the call data packet.
     async writeCallData(data, complete, error) {
         await this.writeCallDataPacket(data, complete, error);
@@ -55,13 +114,16 @@ export class CommonRPC {
         }, writeOptions);
     }
     // writeCallCancel writes the call cancel packet.
-    async writeCallCancel() {
+    async writeCallCancel(waitForDrain = false) {
         await this.writePacket({
             body: {
                 case: 'callCancel',
                 value: true,
             },
         }, { waitForDrain: false });
+        if (waitForDrain) {
+            await this._source.onEmpty({ signal: this.writeDrainAbort.signal });
+        }
     }
     // writeCallDataFromSource writes all call data from the iterable.
     async writeCallDataFromSource(dataSource) {
@@ -153,16 +215,27 @@ export class CommonRPC {
             throw new Error('call start must be sent before call data');
         }
         this.pushRpcData(packet.data, packet.dataIsZero);
-        if (packet.error) {
-            this._rpcDataSource.end(new RemoteRPCError(this.service, this.method, packet.error));
+        const remoteError = packet.error
+            ? new RemoteRPCError(this.service, this.method, packet.error)
+            : undefined;
+        if (remoteError) {
+            this.remoteError ??= remoteError;
+            this.invocationController.abort();
+            this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST);
         }
-        else if (packet.complete) {
-            this._rpcDataSource.end();
+        if (packet.complete && !remoteError) {
+            this.remoteCompleted = true;
+            this.recordRemoteTerminal(TerminalKind.COMMITTED);
+            this._rpcDataSource.end(remoteError);
+        }
+        else if (remoteError) {
+            this._rpcDataSource.end(remoteError);
         }
     }
     // handleCallCancel handles a CallCancel packet.
     async handleCallCancel() {
-        this.close(new Error(ERR_RPC_ABORT));
+        this.recordRemoteTerminal(TerminalKind.CANCELED);
+        await this.close(new Error(ERR_RPC_ABORT));
     }
     // close closes the call, optionally with an error.
     async close(err) {
@@ -170,6 +243,11 @@ export class CommonRPC {
             return;
         }
         this.closed = err ?? true;
+        if (!this.remoteError && err) {
+            this.remoteError = err;
+        }
+        this.recordRemoteTerminal(err ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED);
+        this.invocationController.abort();
         // note: this does nothing if _source is already ended.
         if (err && err.message) {
             await this.writeCallDataPacket(undefined, true, err.message, {
@@ -181,22 +259,21 @@ export class CommonRPC {
         this._source.end();
         this._rpcDataSource.end(err);
     }
-    // _createSink returns a value for the sink field.
     _createSink() {
         return async (source) => {
             try {
                 if (Symbol.asyncIterator in source) {
-                    // Handle async source
                     for await (const msg of source) {
                         await this.handlePacket(msg);
                     }
                 }
                 else {
-                    // Handle sync source
                     for (const msg of source) {
                         await this.handlePacket(msg);
                     }
                 }
+                this.remoteSourceClosed = true;
+                this.recordRemoteTerminal(TerminalKind.CLOSED);
             }
             catch (err) {
                 this.close(err);

package/dist/srpc/handler.d.ts

@@ -1,6 +1,7 @@
 import type { Sink, Source } from 'it-stream-types';
 import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js';
-export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>) => Promise<void>;
+import type { ServerInvocation } from './server-invocation.js';
+export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, invocation?: ServerInvocation) => Promise<void>;
 export interface Handler {
     getServiceID(): string;
     getMethodIDs(): string[];

package/dist/srpc/index.d.ts

@@ -1,5 +1,9 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
+export { CallReceipt } from './call-receipt.js';
+export type { HeldCall, ReceiptRpc } from './call-receipt.js';
+export { ServerInvocation } from './server-invocation.js';
+export { TerminalKind } from './rpcproto.pb.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export type { StreamConnParams, StreamHandler } from './conn.js';

package/dist/srpc/index.js

@@ -1,5 +1,8 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
+export { CallReceipt } from './call-receipt.js';
+export { ServerInvocation } from './server-invocation.js';
+export { TerminalKind } from './rpcproto.pb.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export { WebSocketConn } from './websocket.js';

package/dist/srpc/invoker.d.ts

@@ -2,5 +2,6 @@ import type { MethodDefinition } from './definition.js';
 import { InvokeFn } from './handler.js';
 import type { MessageType, Message } from '@aptre/protobuf-es-lite';
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite';
-export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R) => Promise<O>) | ((request: R) => AsyncIterable<O>) | ((request: AsyncIterable<R>) => Promise<O>) | ((request: AsyncIterable<R>) => AsyncIterable<O>);
+import type { ServerInvocation } from './server-invocation.js';
+export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R, invocation?: ServerInvocation) => Promise<O>) | ((request: R, invocation?: ServerInvocation) => AsyncIterable<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => Promise<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => AsyncIterable<O>);
 export declare function createInvokeFn<R extends Message<R>, O extends Message<O>>(methodInfo: MethodDefinition<MessageType<R>, MessageType<O>, MethodKind, MethodIdempotency | undefined>, methodProto: MethodProto<R, O>): InvokeFn;