@agentunion/fastaun 0.5.31 → 0.5.33

package/dist/transport.js

@@ -19,8 +19,15 @@ import { messageClassOf } from './client/control-messages.js';
 const MAX_WS_PAYLOAD_SIZE = 1_000_000;
 const MAX_RPC_INFLIGHT = 16;
 const MAX_BACKGROUND_RPC_INFLIGHT = 8;
+const MAX_EVENT_RPC_INFLIGHT = 4;
+const MAX_PULL_RPC_INFLIGHT = 4;
 const WORKER_START_TIMEOUT_MS = 2_000;
 const SHORT_RPC_WORKER_START_TIMEOUT_MS = 2_000;
+function normalizeRpcBackground(value) {
+    if (value === 'event' || value === 'pull')
+        return value;
+    return value === true ? true : false;
+}
 const _noopLogger = {
     error: () => { },
     warn: () => { },
@@ -569,9 +576,14 @@ export class RPCTransport {
     _pending = new Map();
     _pendingMeta = new Map();
     _pendingBackground = new Set();
+    _pendingEvent = new Set();
+    _pendingPull = new Set();
     _rpcQueue = [];
     _backgroundRpcQueue = [];
     _drainingRpcQueue = false;
+    _rateLimitUntil = 0;
+    _rateLimitTimer = null;
+    _rateLimitWaiters = new Set();
     _onForegroundDrained;
     _onRpcResponse;
     _sendQueue = [];
@@ -605,6 +617,19 @@ export class RPCTransport {
     _workerConnectAttempt = 0;
     _workerBufferedEvents = [];
     _workerOptions;
+    get inflightCounts() {
+        return {
+            total: this._pending.size,
+            background: this._pendingBackground.size,
+            event: this._pendingEvent.size,
+            pull: this._pendingPull.size,
+        };
+    }
+    get foregroundWaiting() {
+        return this._rpcQueue.length;
+    }
+    _eventBackpressure(timeout = 30_000) { if (this._worker)
+        return this._workerCommand({ type: 'event_backpressure', timeout }); return Promise.resolve(this.foregroundWaiting > 0 || Number(this._ws?.bufferedAmount ?? 0) >= 65536); }
     constructor(opts) {
         this._logger = opts.logger ?? _noopLogger;
         this._dispatcher = opts.eventDispatcher;
@@ -782,6 +807,8 @@ export class RPCTransport {
         }
         this._workerDisabled = true;
         this._workerConnected = false;
+        for (const wake of this._rateLimitWaiters)
+            wake();
         this._workerConnecting = false;
         this._workerGeneration = null;
         this._workerBufferedEvents = [];
@@ -837,6 +864,12 @@ export class RPCTransport {
         }
         if (this._workerGeneration === null || message.generation !== this._workerGeneration)
             return;
+        if (message.event === '_transport.rate_limit') {
+            const until = Number(message.payload?.until_ms);
+            if (Number.isFinite(until))
+                this._rateLimitUntil = Math.max(this._rateLimitUntil, until);
+            return;
+        }
         if (message.event === '_transport.risk_control') {
             this._dispatchRiskControl(message.payload, () => message.generation === this._workerGeneration);
             return;
@@ -856,6 +889,8 @@ export class RPCTransport {
         }
         if (message.event === '_transport.disconnect') {
             this._workerConnected = false;
+            for (const wake of this._rateLimitWaiters)
+                wake();
             this._workerGeneration = null;
             const payload = (message.payload && typeof message.payload === 'object')
                 ? { ...message.payload }
@@ -911,7 +946,7 @@ export class RPCTransport {
         const id = `worker-${++this._workerSeq}`;
         const timeoutMs = command.type === 'call'
             ? null
-            : command.type === 'connect' ? this._connectTimeout + 1_000 : 30_000;
+            : command.type === 'connect' ? this._connectTimeout + 1_000 : command.type === 'event_backpressure' ? command.timeout ?? 30_000 : 30_000;
         let posted = false;
         const promise = new Promise((resolve, reject) => {
             const timer = timeoutMs === null ? null : setTimeout(() => {
@@ -1495,6 +1530,9 @@ export class RPCTransport {
     async close() {
         if (this._worker) {
             const worker = this._worker;
+            this._workerConnected = false;
+            for (const wake of this._rateLimitWaiters)
+                wake();
             try {
                 await this._workerCommand({ type: 'close' });
             }
@@ -1531,6 +1569,11 @@ export class RPCTransport {
         this._handshakeAbort = null;
         abortHandshake?.();
         this._closed = true;
+        for (const wake of this._rateLimitWaiters)
+            wake();
+        if (this._rateLimitTimer !== null)
+            clearTimeout(this._rateLimitTimer);
+        this._rateLimitTimer = null;
         this._riskDeliveries = 0;
         this._startSendQueue();
         this._connectionGeneration += 1;
@@ -1543,6 +1586,8 @@ export class RPCTransport {
         this._pending.clear();
         this._pendingMeta.clear();
         this._pendingBackground.clear();
+        this._pendingEvent.clear();
+        this._pendingPull.clear();
         for (const queued of this._rpcQueue) {
             clearTimeout(queued.pending.timer);
             queued.pending.reject(new ConnectionError('transport closed'));
@@ -1647,7 +1692,7 @@ export class RPCTransport {
             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, ...(onSent ? { trackSent: true } : {}) }, undefined, onSent, sentCheckpoint);
+            const request = this._workerCommand({ type: 'call', method, params, timeout, trace, background, rateLimitUntil: this._rateLimitUntil, ...(onSent ? { trackSent: true } : {}) }, undefined, onSent, sentCheckpoint);
             const result = request.then((result) => {
                 responseLog.debug(`RPC response ok: method=${method}`);
                 return result;
@@ -1667,15 +1712,20 @@ export class RPCTransport {
             });
         }
         const rpcId = `rpc-${crypto.randomBytes(8).toString('hex')}`;
-        const effectiveTimeout = timeout ?? this._timeout;
+        const deadline = typeof params?._rpc_deadline === 'number' ? params._rpc_deadline : undefined;
+        const effectiveTimeout = deadline === undefined ? timeout ?? this._timeout : Math.min(timeout ?? this._timeout, deadline - Date.now());
+        if (effectiveTimeout <= 0)
+            throw new TimeoutError(`rpc timeout before send: ${method}`, { retryable: true });
         const tStart = Date.now();
         // 注入 _trace（会话级或调用级 mode 非 off 时）
         const effectiveTraceMode = (trace === 'off' || trace === 'log' || trace === 'diag') ? trace : this._traceMode;
         let traceId = '';
         const sendParams = { ...(params ?? {}) };
         const localParams = sendParams;
-        const backgroundRpc = background || localParams._rpc_background === true;
+        const selectedBackground = normalizeRpcBackground(background !== false ? background : localParams._rpc_background);
+        const backgroundRpc = selectedBackground === true && ['message.peers', 'message.pull', 'message.v2.pull', 'message.ack', 'message.v2.ack', 'group.pull', 'group.v2.pull', 'group.pull_events', 'group.ack_messages', 'group.v2.ack'].includes(method) ? 'pull' : selectedBackground;
         delete localParams._rpc_background;
+        delete localParams._rpc_deadline;
         const requestContext = trafficLogContext('outbound', sendParams);
         const requestLog = withLogContext(this._logger, requestContext);
         const responseLog = withLogContext(requestLog, {
@@ -1706,7 +1756,9 @@ export class RPCTransport {
             const timer = setTimeout(() => {
                 this._removeRpc(rpcId, pending);
                 requestLog.warn(`RPC timeout: method=${method}, id=${rpcId}, elapsed=${Date.now() - tStart}ms, timeout=${effectiveTimeout}ms`);
-                reject(new TimeoutError(`rpc timeout: ${method}`, { retryable: true }));
+                reject(backgroundRpc && !pending.sent && this._rateLimitRemainingMs() > 0
+                    ? this._rateLimitError()
+                    : new TimeoutError(`rpc timeout: ${method}`, { retryable: true }));
                 this._drainRpcQueue();
             }, effectiveTimeout);
             const pending = {
@@ -1787,7 +1839,7 @@ export class RPCTransport {
                     pending,
                     tStart,
                     timeoutMs: effectiveTimeout,
-                    background: true,
+                    background: backgroundRpc,
                     priority: this._messagePriority(localParams.message_class),
                     logger: requestLog,
                     onSent,
@@ -1843,6 +1895,64 @@ export class RPCTransport {
     }
     _messagePriority(messageClass) { return messageClass === 'sdk_control' ? 2 : messageClass === 'control' ? 1 : 0; }
     _isRiskControlMethod(method) { return ['gateway.risk_ack', 'meta.ping', 'system.ping', 'ping', 'auth.disconnect'].includes(method); }
+    _rateLimitRemainingMs() { return Math.max(0, this._rateLimitUntil - Date.now()); }
+    _rateLimitError() {
+        const remaining = this._rateLimitRemainingMs();
+        return new RateLimitError('RPC rate limited: local backoff', {
+            code: -32429, retryable: true, data: { retry_after_seconds: Math.ceil(remaining / 1000), retry_after_ms: Math.ceil(remaining) },
+        });
+    }
+    async _waitRateLimit(timeout = this._timeout, signal) {
+        const started = Date.now();
+        while (this._rateLimitRemainingMs() > 0) {
+            if (signal?.aborted)
+                throw new TimeoutError('rpc cancelled', { retryable: true });
+            if (!this.isConnected())
+                throw new ConnectionError('transport closed');
+            const remaining = this._rateLimitRemainingMs();
+            const budget = timeout - (Date.now() - started);
+            if (budget <= 0)
+                throw this._rateLimitError();
+            await new Promise(resolve => {
+                const wake = () => {
+                    clearTimeout(timer);
+                    this._rateLimitWaiters.delete(wake);
+                    signal?.removeEventListener('abort', wake);
+                    resolve();
+                };
+                const timer = setTimeout(wake, Math.min(remaining, budget, 2_147_483_647));
+                this._rateLimitWaiters.add(wake);
+                signal?.addEventListener('abort', wake, { once: true });
+            });
+        }
+    }
+    _observeRateLimit(error) {
+        if (![4290, 429, -32429, -32029].includes(Number(error.code)))
+            return;
+        const data = error.data;
+        const seconds = Number(data?.retry_after_seconds);
+        const milliseconds = Number(data?.retry_after_ms);
+        this._rateLimitUntil = Math.max(this._rateLimitUntil, Date.now() + Math.max(60_000, Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 0, Number.isFinite(milliseconds) && milliseconds > 0 ? milliseconds : 0));
+        this._worker?.postMessage({ type: 'rate_limit', rateLimitUntil: this._rateLimitUntil });
+        if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
+            parentPort.postMessage({ type: 'event', generation: this._connectionGeneration, event: '_transport.rate_limit', payload: { until_ms: this._rateLimitUntil } });
+        }
+    }
+    _canDispatch(entry) {
+        if (this._pending.size >= MAX_RPC_INFLIGHT && !this._isRiskControlMethod(entry.method))
+            return false;
+        if (!entry.background)
+            return true;
+        if (this._rateLimitRemainingMs() > 0)
+            return false;
+        if (this._pendingBackground.size >= MAX_BACKGROUND_RPC_INFLIGHT)
+            return false;
+        if (entry.background === 'event')
+            return this._pendingEvent.size < MAX_EVENT_RPC_INFLIGHT;
+        if (entry.background === 'pull')
+            return this._pendingPull.size < MAX_PULL_RPC_INFLIGHT;
+        return true;
+    }
     _enqueueSend(task, priority = 0) {
         const result = new Promise((resolve, reject) => { this._sendQueue.push({ task, priority, resolve, reject }); });
         this._startSendQueue();
@@ -1956,6 +2066,8 @@ export class RPCTransport {
             this._pending.delete(rpcId);
             this._pendingMeta.delete(rpcId);
             this._pendingBackground.delete(rpcId);
+            this._pendingEvent.delete(rpcId);
+            this._pendingPull.delete(rpcId);
         }
         if (this._rpcQueue.length > 0) {
             this._rpcQueue = this._rpcQueue.filter((entry) => entry.rpcId !== rpcId || (pending !== undefined && entry.pending !== pending));
@@ -1979,10 +2091,12 @@ export class RPCTransport {
                 let entry;
                 let selectedQueue;
                 let selectedIndex = -1;
-                for (const queue of [this._rpcQueue, ...(this._pendingBackground.size < MAX_BACKGROUND_RPC_INFLIGHT ? [this._backgroundRpcQueue] : [])]) {
+                for (const queue of [this._rpcQueue, this._backgroundRpcQueue]) {
                     for (let index = 0; index < queue.length; index++) {
                         if (controlOnly && !this._isRiskControlMethod(queue[index].method))
                             continue;
+                        if (!this._canDispatch(queue[index]))
+                            continue;
                         if (!entry || queue[index].priority > entry.priority) {
                             entry = queue[index];
                             selectedQueue = queue;
@@ -1999,7 +2113,9 @@ export class RPCTransport {
                 if (elapsed >= entry.timeoutMs) {
                     clearTimeout(entry.pending.timer);
                     entry.logger.warn(`RPC queue timeout: method=${entry.method}, id=${entry.rpcId}, elapsed=${elapsed}ms, timeout=${entry.timeoutMs}ms`);
-                    entry.pending.reject(new TimeoutError(`rpc timeout before send: ${entry.method}`, { retryable: true }));
+                    entry.pending.reject(entry.background && this._rateLimitRemainingMs() > 0
+                        ? this._rateLimitError()
+                        : new TimeoutError(`rpc timeout before send: ${entry.method}`, { retryable: true }));
                     continue;
                 }
                 this._pending.set(entry.rpcId, entry.pending);
@@ -2012,16 +2128,36 @@ export class RPCTransport {
                 });
                 if (entry.background) {
                     this._pendingBackground.add(entry.rpcId);
+                    if (entry.background === 'event')
+                        this._pendingEvent.add(entry.rpcId);
+                    if (entry.background === 'pull')
+                        this._pendingPull.add(entry.rpcId);
                 }
+                let deferredForRateLimit = false;
                 this._sendText(entry.payload, `rpc ${entry.method}`, () => {
                     if (this._pending.get(entry.rpcId) !== entry.pending)
                         return false;
+                    if (Date.now() - entry.tStart >= entry.timeoutMs) {
+                        this._removeRpc(entry.rpcId, entry.pending);
+                        entry.pending.reject(new TimeoutError(`rpc timeout before send: ${entry.method}`, { retryable: true }));
+                        return false;
+                    }
+                    if (entry.background && this._rateLimitRemainingMs() > 0) {
+                        deferredForRateLimit = true;
+                        this._removeRpc(entry.rpcId, entry.pending);
+                        this._backgroundRpcQueue.push(entry);
+                        this._drainRpcQueue();
+                        return false;
+                    }
                     this._requestCheck?.(`rpc:${entry.method}`);
+                    entry.pending.sent = true;
                     return true;
                 }, this._isRiskControlMethod(entry.method) ? 3 : entry.priority).then(() => {
                     entry.logger.debug(`RPC request sent: method=${entry.method}, id=${entry.rpcId}, background=${entry.background}`);
                     return entry.onSent?.();
                 }).catch((err) => {
+                    if (deferredForRateLimit)
+                        return;
                     if (this._pending.get(entry.rpcId) !== entry.pending)
                         return;
                     this._removeRpc(entry.rpcId, entry.pending);
@@ -2035,6 +2171,13 @@ export class RPCTransport {
         }
         finally {
             this._drainingRpcQueue = false;
+            if (this._rateLimitTimer !== null)
+                clearTimeout(this._rateLimitTimer);
+            this._rateLimitTimer = null;
+            const remaining = this._rateLimitRemainingMs();
+            if (!this._closed && this._backgroundRpcQueue.length && remaining > 0) {
+                this._rateLimitTimer = setTimeout(() => { this._rateLimitTimer = null; this._drainRpcQueue(); }, Math.min(remaining, 2_147_483_647));
+            }
             if (foregroundDrained)
                 this._onForegroundDrained?.();
         }
@@ -2086,6 +2229,11 @@ export class RPCTransport {
             this._stopWebSocketHeartbeat(ws);
             const wasClosed = this._closed;
             this._closed = true;
+            for (const wake of this._rateLimitWaiters)
+                wake();
+            if (this._rateLimitTimer !== null)
+                clearTimeout(this._rateLimitTimer);
+            this._rateLimitTimer = null;
             this._ws = null;
             this._lastCloseCode = Number.isFinite(code) ? code : null;
             this._logger.debug(`WebSocket closed: code=${code}, intentional close=${wasClosed}`);
@@ -2097,6 +2245,8 @@ export class RPCTransport {
             this._pending.clear();
             this._pendingMeta.clear();
             this._pendingBackground.clear();
+            this._pendingEvent.clear();
+            this._pendingPull.clear();
             for (const queued of this._rpcQueue) {
                 clearTimeout(queued.pending.timer);
                 queued.pending.reject(err);
@@ -2229,12 +2379,16 @@ export class RPCTransport {
                         this._receiveRiskControl(state);
                 delete error.data.risk_state;
             }
+            if (isJsonObject(error))
+                this._observeRateLimit(error);
             const rpcId = String(message.id);
             const pending = this._pending.get(rpcId);
             if (pending) {
                 this._pending.delete(rpcId);
                 this._pendingMeta.delete(rpcId);
                 this._pendingBackground.delete(rpcId);
+                this._pendingEvent.delete(rpcId);
+                this._pendingPull.delete(rpcId);
                 pending.resolve(message);
                 this._drainRpcQueue();
                 this._onRpcResponse?.();
@@ -2424,6 +2578,12 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
     parentPort.on('message', async (command) => {
         const id = command.id;
         try {
+            if (command.type === 'rate_limit') {
+                if (Number.isFinite(command.rateLimitUntil))
+                    actor['_rateLimitUntil'] = Math.max(actor['_rateLimitUntil'], command.rateLimitUntil);
+                actor['_drainRpcQueue']();
+                return;
+            }
             if (command.type === 'risk_release') {
                 if (command.generation === bridgeGeneration())
                     actor['_finishRiskDelivery']();
@@ -2457,12 +2617,14 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
                     break;
                 }
                 case 'call': {
+                    if (Number.isFinite(command.rateLimitUntil))
+                        actor['_rateLimitUntil'] = Math.max(actor['_rateLimitUntil'], command.rateLimitUntil);
                     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)));
+                        }, command.timeout, command.trace, normalizeRpcBackground(command.background))
+                        : actor.call(String(command.method ?? ''), command.params ?? undefined, command.timeout, command.trace, normalizeRpcBackground(command.background)));
                     if (id)
                         active.set(id, request);
                     result = await request;
@@ -2470,6 +2632,9 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
                         active.delete(id);
                     break;
                 }
+                case 'event_backpressure':
+                    result = await actor._eventBackpressure();
+                    break;
                 case 'notify':
                     result = await actor.notify(String(command.method ?? ''), command.params);
                     break;