@agentunion/fastaun 0.5.19 → 0.5.21

package/dist/transport.d.ts

@@ -55,6 +55,7 @@ export declare class RPCTransport {
     private _backgroundRpcQueue;
     private _drainingRpcQueue;
     _onForegroundDrained?: () => void;
+    _onRpcResponse?: () => void;
     private _sendChain;
     private _idCounter;
     private _metaObserver;
@@ -107,6 +108,7 @@ export declare class RPCTransport {
     setMetaObserver(observer: MetaObserver | null): void;
     setProtocolMetaObserver(observer: MetaObserver | null): void;
     setProtocolDisconnectCallback(callback: DisconnectCallback | null): void;
+    getTraceMode(): string;
     /** 设置 trace 模式：off / log / diag */
     setTraceMode(mode: string): void;
     /** 注册 trace observer；observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用。 */
@@ -141,6 +143,8 @@ export declare class RPCTransport {
      * 发送 JSON-RPC 2.0 请求并等待响应。
      */
     call(method: string, params?: RpcParams, timeout?: number, trace?: string, background?: boolean): Promise<RpcResult>;
+    private _callWithSent;
+    private _call;
     private _callLocal;
     /** 发送 JSON-RPC 2.0 Notification，不分配 id，也不等待响应。 */
     notify(method: string, params?: RpcParams | null): Promise<void>;

package/dist/transport.js

@@ -571,6 +571,7 @@ export class RPCTransport {
     _backgroundRpcQueue = [];
     _drainingRpcQueue = false;
     _onForegroundDrained;
+    _onRpcResponse;
     _sendChain = Promise.resolve();
     _idCounter = 0;
     // Gateway 在 RPC envelope 注入 _meta 字段（与 result 同级），由 client 层 observer 接收。
@@ -682,6 +683,11 @@ export class RPCTransport {
                         this._onForegroundDrained?.();
                     return;
                 }
+                if (message.type === 'rpc_response') {
+                    if (this._workerConnected && message.generation === this._workerGeneration)
+                        this._onRpcResponse?.();
+                    return;
+                }
                 if (!message.id)
                     return;
                 const pending = this._workerPending.get(message.id);
@@ -707,6 +713,12 @@ export class RPCTransport {
                     pending.reject(new ConnectionError('stale transport worker response'));
                     return;
                 }
+                if (message.type === 'sent') {
+                    const onSent = pending.onSent;
+                    delete pending.onSent;
+                    void onSent?.();
+                    return;
+                }
                 this._workerPending.delete(message.id);
                 if (pending.timer !== null)
                     clearTimeout(pending.timer);
@@ -714,15 +726,22 @@ export class RPCTransport {
                     && message.ok && typeof message.generation === 'number') {
                     this._workerGeneration = message.generation;
                 }
-                if (message.ok)
-                    pending.resolve(message.result);
-                else {
-                    if (pending.commandType === 'connect' && pending.connectAttempt === this._workerConnectAttempt) {
-                        this._workerGeneration = null;
-                        this._workerBufferedEvents = [];
+                const settleReply = () => {
+                    if (message.ok)
+                        pending.resolve(message.result);
+                    else {
+                        if (pending.commandType === 'connect' && pending.connectAttempt === this._workerConnectAttempt) {
+                            this._workerGeneration = null;
+                            this._workerBufferedEvents = [];
+                        }
+                        pending.reject(deserializeWorkerError(message.error));
                     }
-                    pending.reject(deserializeWorkerError(message.error));
+                };
+                if (pending.sentCheckpoint && (message.ok || !pending.onSent)) {
+                    void pending.sentCheckpoint.then(settleReply, pending.reject);
                 }
+                else
+                    settleReply();
             });
             worker.on('error', (error) => {
                 this._disableNetworkWorker(worker, error);
@@ -861,7 +880,7 @@ export class RPCTransport {
         for (const message of buffered)
             this._handleWorkerEvent(message);
     }
-    _workerCommand(command, connectAttempt) {
+    _workerCommand(command, connectAttempt, onSent, sentCheckpoint) {
         this._ensureNetworkWorker();
         if (!this._worker)
             return Promise.reject(new ConnectionError('transport worker unavailable'));
@@ -892,6 +911,8 @@ export class RPCTransport {
                 timer,
                 commandType: command.type,
                 connectAttempt,
+                onSent,
+                sentCheckpoint,
             });
             const postCommand = () => {
                 if (!this._workerPending.has(id))
@@ -981,6 +1002,9 @@ export class RPCTransport {
         this._onDisconnect = callback;
         this._protocolDisconnectCallback = callback !== null;
     }
+    getTraceMode() {
+        return this._traceMode;
+    }
     /** 设置 trace 模式：off / log / diag */
     setTraceMode(mode) {
         if (mode !== 'off' && mode !== 'log' && mode !== 'diag') {
@@ -1482,12 +1506,34 @@ export class RPCTransport {
      * 发送 JSON-RPC 2.0 请求并等待响应。
      */
     call(method, params, timeout, trace, background = false) {
+        return this._call(method, params, timeout, trace, background);
+    }
+    _callWithSent(method, params, onSent, timeout, trace, background = false) {
+        let resolveSent;
+        let rejectSent;
+        const sent = new Promise((resolve, reject) => { resolveSent = resolve; rejectSent = reject; });
+        let request;
+        const recordSent = async () => {
+            try {
+                await onSent();
+                resolveSent();
+            }
+            catch (error) {
+                rejectSent(error);
+                request?.cancel?.();
+            }
+        };
+        request = this._call(method, params, timeout, trace, background, recordSent, sent);
+        const result = Promise.all([request, sent]).then(([response]) => response);
+        return Object.assign(result, { cancel: request.cancel });
+    }
+    _call(method, params, timeout, trace, background = false, onSent, sentCheckpoint) {
         if (this._worker) {
             const requestContext = trafficLogContext('outbound', params ?? {});
             const requestLog = withLogContext(this._logger, requestContext);
             const responseLog = withLogContext(requestLog, { direction: 'inbound', peerAid: requestContext.peerAid });
             requestLog.debug(`RPC request queued: method=${method}`);
-            const request = this._workerCommand({ type: 'call', method, params, timeout, trace, background });
+            const request = this._workerCommand({ type: 'call', method, params, timeout, trace, background, ...(onSent ? { trackSent: true } : {}) }, undefined, onSent, sentCheckpoint);
             const result = request.then((result) => {
                 responseLog.debug(`RPC response ok: method=${method}`);
                 return result;
@@ -1497,9 +1543,9 @@ export class RPCTransport {
             });
             return Object.assign(result, { cancel: request.cancel });
         }
-        return this._enqueueActorStart(() => this._callLocal(method, params, timeout, trace, background), () => new TimeoutError(`rpc cancelled: ${method}`, { retryable: true }));
+        return this._enqueueActorStart(() => this._callLocal(method, params, timeout, trace, background, onSent, sentCheckpoint), () => new TimeoutError(`rpc cancelled: ${method}`, { retryable: true }));
     }
-    _callLocal(method, params, timeout, trace, background = false) {
+    _callLocal(method, params, timeout, trace, background = false, onSent, sentCheckpoint) {
         if (this._closed || !this._ws) {
             const suffix = this._lastCloseCode !== null ? `: close code ${this._lastCloseCode}` : '';
             throw new ConnectionError(`transport not connected${suffix}`, {
@@ -1552,42 +1598,48 @@ export class RPCTransport {
             const pending = {
                 resolve: (response) => {
                     clearTimeout(timer);
-                    const elapsed = Date.now() - tStart;
-                    if (response.error !== undefined) {
-                        responseLog.debug(`RPC error response: method=${method}, id=${rpcId}, elapsed=${elapsed}ms, error=${JSON.stringify(response.error)}`);
-                        if (traceId) {
-                            responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=error`);
-                        }
-                        // 处理 error 路径的 _trace
-                        const respTrace = response._trace;
-                        if (respTrace && typeof respTrace === 'object' && !Array.isArray(respTrace)) {
-                            this._handleResponseTrace(method, 'error', elapsed, respTrace, responseLog);
-                        }
-                        reject(mapRemoteError(response.error));
-                    }
-                    else if (response.result !== undefined) {
-                        responseLog.debug(`RPC response ok: method=${method}, id=${rpcId}, elapsed=${elapsed}ms ${summarizeDict(response.result, DIAG_RESULT_FIELDS)}`);
-                        if (traceId) {
-                            responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
+                    const acceptResponse = () => {
+                        const elapsed = Date.now() - tStart;
+                        if (response.error !== undefined) {
+                            responseLog.debug(`RPC error response: method=${method}, id=${rpcId}, elapsed=${elapsed}ms, error=${JSON.stringify(response.error)}`);
+                            if (traceId) {
+                                responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=error`);
+                            }
+                            // 处理 error 路径的 _trace
+                            const respTrace = response._trace;
+                            if (respTrace && typeof respTrace === 'object' && !Array.isArray(respTrace)) {
+                                this._handleResponseTrace(method, 'error', elapsed, respTrace, responseLog);
+                            }
+                            reject(mapRemoteError(response.error));
                         }
-                        // 透传 envelope._meta 给 observer
-                        if (this._metaObserver !== null) {
-                            const meta = response._meta;
-                            if (meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-                                this._queueObserver('meta_observer', this._metaObserver, meta);
+                        else if (response.result !== undefined) {
+                            responseLog.debug(`RPC response ok: method=${method}, id=${rpcId}, elapsed=${elapsed}ms ${summarizeDict(response.result, DIAG_RESULT_FIELDS)}`);
+                            if (traceId) {
+                                responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
                             }
+                            // 透传 envelope._meta 给 observer
+                            if (this._metaObserver !== null) {
+                                const meta = response._meta;
+                                if (meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
+                                    this._queueObserver('meta_observer', this._metaObserver, meta);
+                                }
+                            }
+                            // 处理 success 路径的 _trace
+                            const respTrace = response._trace;
+                            if (respTrace && typeof respTrace === 'object' && !Array.isArray(respTrace)) {
+                                this._handleResponseTrace(method, 'ok', elapsed, respTrace, responseLog);
+                            }
+                            resolve(response.result);
                         }
-                        // 处理 success 路径的 _trace
-                        const respTrace = response._trace;
-                        if (respTrace && typeof respTrace === 'object' && !Array.isArray(respTrace)) {
-                            this._handleResponseTrace(method, 'ok', elapsed, respTrace, responseLog);
+                        else {
+                            responseLog.warn(`RPC response missing result or error: method=${method}, id=${rpcId}, elapsed=${elapsed}ms`);
+                            reject(new SerializationError(`rpc response missing result and error: ${method}`));
                         }
-                        resolve(response.result);
-                    }
-                    else {
-                        responseLog.warn(`RPC response missing result or error: method=${method}, id=${rpcId}, elapsed=${elapsed}ms`);
-                        reject(new SerializationError(`rpc response missing result and error: ${method}`));
-                    }
+                    };
+                    if (sentCheckpoint)
+                        void sentCheckpoint.then(acceptResponse, reject);
+                    else
+                        acceptResponse();
                 },
                 reject: (err) => {
                     clearTimeout(timer);
@@ -1609,6 +1661,7 @@ export class RPCTransport {
                 timeoutMs: effectiveTimeout,
                 background: backgroundRpc,
                 logger: requestLog,
+                onSent,
             });
             if (backgroundRpc) {
                 this._rpcQueue.pop();
@@ -1621,6 +1674,7 @@ export class RPCTransport {
                     timeoutMs: effectiveTimeout,
                     background: true,
                     logger: requestLog,
+                    onSent,
                 });
             }
             this._drainRpcQueue();
@@ -1798,6 +1852,7 @@ export class RPCTransport {
                 }
                 this._sendText(entry.payload, `rpc ${entry.method}`, () => this._pending.get(entry.rpcId) === entry.pending).then(() => {
                     entry.logger.debug(`RPC request sent: method=${entry.method}, id=${entry.rpcId}, background=${entry.background}`);
+                    return entry.onSent?.();
                 }).catch((err) => {
                     if (this._pending.get(entry.rpcId) !== entry.pending)
                         return;
@@ -1997,6 +2052,7 @@ export class RPCTransport {
                 this._pendingBackground.delete(rpcId);
                 pending.resolve(message);
                 this._drainRpcQueue();
+                this._onRpcResponse?.();
             }
             return;
         }
@@ -2155,6 +2211,9 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
     actor._onForegroundDrained = () => parentPort.postMessage({
         type: 'foreground_drained', generation: bridgeGeneration(),
     });
+    actor._onRpcResponse = () => parentPort.postMessage({
+        type: 'rpc_response', generation: bridgeGeneration(),
+    });
     actor.setProtocolMetaObserver((meta) => workerDispatcher.enqueueProtocol('_transport.observer', {
         kind: 'meta_observer', payload: meta,
     }));
@@ -2189,7 +2248,12 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
                     break;
                 }
                 case 'call': {
-                    const request = actor.call(String(command.method ?? ''), command.params ?? undefined, command.timeout, command.trace, Boolean(command.background));
+                    const request = (command.trackSent
+                        ? actor['_callWithSent'](String(command.method ?? ''), command.params ?? undefined, async () => {
+                            if (id)
+                                parentPort.postMessage({ type: 'sent', id, generation: bridgeGeneration() });
+                        }, command.timeout, command.trace, Boolean(command.background))
+                        : actor.call(String(command.method ?? ''), command.params ?? undefined, command.timeout, command.trace, Boolean(command.background)));
                     if (id)
                         active.set(id, request);
                     result = await request;