@agentunion/fastaun 0.5.20 → 0.5.21

package/dist/client/rpc-pipeline.d.ts

@@ -13,6 +13,8 @@ export declare class RpcPipeline {
     private pullDrainedCheckQueued;
     constructor(runtime: ClientRuntime);
     call(method: string, params?: RpcParams): Promise<RpcResult>;
+    private _callWithSent;
+    private _call;
     preflight(method: string, params?: RpcParams): RpcPreflightResult;
     mergeInstanceProtectedHeaders(method: string, params: RpcParams): void;
     normalizeOutboundMessagePayload(params: RpcParams, method?: string): void;
@@ -43,7 +45,8 @@ export declare class RpcPipeline {
     isPullNamespaceCurrent(namespace: string): boolean;
     invalidatePulls(): Promise<void>;
     private pullInvalidationInProgress;
-    runPullSerialized<T>(key: string, operation: () => Promise<T> | T, background?: boolean): Promise<T>;
+    runPullNamespaceSerialized<T>(key: string, operation: () => Promise<T> | T, background?: boolean): Promise<T>;
+    runPullSerialized<T>(key: string, operation: () => Promise<T> | T, background?: boolean, namespaceOnly?: boolean): Promise<T>;
     private executePullOperation;
     private throwIfPullInvalidated;
     yieldPullGate(key: string, nextKey?: string, background?: boolean): Promise<void>;

package/dist/client/rpc-pipeline.js

@@ -1,5 +1,5 @@
 import * as crypto from 'node:crypto';
-import { normalizeSlotId, slotIsolationKey } from '../config.js';
+import { _INTERNAL_MESSAGE_FLOW_LIMITS, normalizeSlotId, slotIsolationKey } from '../config.js';
 import { certTimeError } from '../cert-utils.js';
 import { orgRequestParams, validateOrgRequestJSON } from '../org-protocol.js';
 import { canonicalJson as canonicalClientRequest } from '../v2/crypto/canonical.js';
@@ -115,7 +115,6 @@ function getCertFingerprint(certPem) {
 /** 旧式 tryAcquirePullGate 的防并发窗口。 */
 const PULL_GATE_STALE_MS = 35_000;
 const PULL_GATE_OPERATION_TIMEOUT_MS = 35_000;
-const PULL_GATE_MAX_ACTIVE = 4;
 function sameIdentityAdmissionRejection(error, original) {
     const errorCode = Number(error?.code);
     const originalCode = Number(original?.code);
@@ -167,6 +166,12 @@ export class RpcPipeline {
         this.runtime = runtime;
     }
     async call(method, params) {
+        return this._call(method, params);
+    }
+    async _callWithSent(method, params, onSent) {
+        return this._call(method, params, onSent);
+    }
+    async _call(method, params, onSent) {
         const client = this.runtime.client;
         const generation = client._delivery?.captureInlineAckGeneration?.();
         const tStart = Date.now();
@@ -194,6 +199,23 @@ export class RpcPipeline {
             const deferGroupReadyPostprocess = Boolean(p._defer_group_ready_postprocess);
             delete p._defer_group_ready_postprocess;
             const pullGateKey = this.pullGateKeyForCall(method, p);
+            if (client._p2pPeerPullEnabled && method === 'message.peers')
+                return await client._delivery.peers(p, rpcBackground);
+            if (client._p2pPeerPullEnabled && (method === 'message.pull' || method === 'message.v2.pull')) {
+                await client._ensureV2SessionReady('message.pull');
+                return await client._delivery.pullPeers(p, rpcBackground);
+            }
+            if (client._p2pPeerPullEnabled && method === 'message.history') {
+                await client._ensureV2SessionReady('message.history');
+                const key = this.pullGateKeyForCall(method, p);
+                return await this.runPullNamespaceSerialized(key, () => client._v2E2EE.peerHistoryV2(p), rpcBackground);
+            }
+            if (client._p2pPeerPullEnabled && (method === 'message.ack' || method === 'message.v2.ack')) {
+                const sender = String(p.sender_aid ?? '').trim();
+                if (!sender)
+                    throw new ValidationError('peer ACK requires sender_aid');
+                return await client._v2E2EE.ackPeerV2(sender, requestedAckSeq || undefined, Array.isArray(p.volatile_cursors) ? p.volatile_cursors : [], Array.isArray(p.volatile_ids) ? p.volatile_ids : []);
+            }
             const runWithPullResponseScope = async (operation) => {
                 const scope = pullGateNamespace || (pullGateKey ? this.pullScopeKey(pullGateKey) : '');
                 const wrapper = client._withPullResponseProcessing;
@@ -207,9 +229,13 @@ export class RpcPipeline {
                 lockedParams._pull_gate_namespace = this.pullScopeKey(pullGateKey);
                 if (pullBackground)
                     lockedParams._rpc_background = true;
+                else
+                    lockedParams._rpc_foreground = true;
                 if (skipSendResultEnvelope)
                     lockedParams._skip_send_result_envelope = true;
-                return await this.runPullSerialized(pullGateKey, async () => this.call(method, lockedParams), pullBackground);
+                const run = ['group.pull', 'group.v2.pull', 'group.history'].includes(method)
+                    ? this.runPullNamespaceSerialized.bind(this) : this.runPullSerialized.bind(this);
+                return await run(pullGateKey, async () => this.call(method, lockedParams), pullBackground);
             }
             if (method === 'message.send') {
                 const encrypt = p.encrypt ?? true;
@@ -222,6 +248,7 @@ export class RpcPipeline {
                         ttl: p.ttl,
                         protectedHeaders: client._protectedHeadersFromParams(p),
                         context: isJsonObject(p.context) ? p.context : undefined,
+                        needRender: p.need_render,
                     }));
                 }
                 client._maybeAppendEchoTraceSend(p);
@@ -236,6 +263,7 @@ export class RpcPipeline {
                         timestamp: p.timestamp,
                         protectedHeaders: client._protectedHeadersFromParams(p),
                         context: isJsonObject(p.context) ? p.context : undefined,
+                        needRender: p.need_render,
                     }));
                 }
                 client._maybeAppendEchoTraceSend(p);
@@ -298,12 +326,12 @@ export class RpcPipeline {
                 }
                 await client._ensureV2SessionReady('group.pull');
                 if (p.window_mode === 'tail') {
-                    return await runWithPullResponseScope(() => client._v2E2EE.pullGroupV2TailInternal(p));
+                    return await runWithPullResponseScope(() => client._v2E2EE.pullGroupV2TailInternal(p, false, true));
                 }
                 const hasExplicitAfterSeq = 'after_seq' in p || 'after_message_seq' in p;
                 const cursorParams = this.explicitGroupCursorParams(p);
                 const ownsCursor = Object.keys(cursorParams).length === 0 || this.groupCursorTargetsCurrentInstance(cursorParams);
-                const pullOpts = { gateLocked: true };
+                const pullOpts = { gateLocked: true, background: rpcBackground };
                 if (hasExplicitAfterSeq)
                     pullOpts.explicitAfterSeq = true;
                 if (p.force === true)
@@ -316,7 +344,7 @@ export class RpcPipeline {
                     pullOpts.wireGroupId = String(p.group_id).trim();
                 if (String(p.group_aid ?? '').trim())
                     pullOpts.groupAid = String(p.group_aid).trim();
-                const messages = await runWithPullResponseScope(() => runWithRpcPriority(() => client._pullGroupV2(String(p.group_id ?? p.group_aid), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, pullOpts)));
+                const messages = await runWithPullResponseScope(() => client._pullGroupV2(String(p.group_id ?? p.group_aid), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, pullOpts));
                 return { messages };
             }
             if (method === 'group.history') {
@@ -349,13 +377,15 @@ export class RpcPipeline {
                 client._clientLog.debug(`thought.get transport call start: method=${method}, params=${client._debugJson(client._messageEnvelopeFieldsForDebug(p))}`);
             }
             const invokeTransport = () => {
-                const request = callTimeout
-                    ? (rpcBackground
-                        ? client._transport.call(method, p, callTimeout, undefined, true)
-                        : client._transport.call(method, p, callTimeout))
-                    : (rpcBackground
-                        ? client._transport.call(method, p, undefined, undefined, true)
-                        : client._transport.call(method, p));
+                const request = onSent
+                    ? client._transport['_callWithSent'](method, p, onSent, callTimeout, undefined, rpcBackground)
+                    : callTimeout
+                        ? (rpcBackground
+                            ? client._transport.call(method, p, callTimeout, undefined, true)
+                            : client._transport.call(method, p, callTimeout))
+                        : (rpcBackground
+                            ? client._transport.call(method, p, undefined, undefined, true)
+                            : client._transport.call(method, p));
                 return this.bindActivePullCancellation(method, p, request);
             };
             let result = await this.transportCallWithIdentityRecovery(invokeTransport, method, p);
@@ -392,8 +422,11 @@ export class RpcPipeline {
         }
         const p = { ...(params ?? {}) };
         this.mergeInstanceProtectedHeaders(method, p);
-        const rpcBackground = Boolean(p._rpc_background) || client._backgroundRpcDepth > 0;
+        const rpcBackground = !Boolean(p._rpc_foreground)
+            && (Boolean(p._rpc_background)
+                || (!['message.peers', 'message.pull', 'message.v2.pull', 'group.pull', 'group.v2.pull', 'group.history', 'group.pull_events'].includes(method) && client._backgroundRpcDepth > 0));
         delete p._rpc_background;
+        delete p._rpc_foreground;
         if (method === 'message.send' || method === 'group.send') {
             this.normalizeOutboundMessagePayload(p, method);
             const messageId = String(p.message_id ?? '').trim();
@@ -430,6 +463,9 @@ export class RpcPipeline {
         }
     }
     validateOutboundCall(method, params) {
+        if ((method === 'message.send' || method === 'group.send') && params.need_render !== undefined && typeof params.need_render !== 'boolean') {
+            throw new ValidationError('need_render must be a boolean');
+        }
         if (method === 'message.send') {
             this.validateMessageRecipient(params.to);
             // 校验目标 AID 格式（拒绝 __system__ 等非法格式）
@@ -492,7 +528,7 @@ export class RpcPipeline {
         }
     }
     injectMessageCursorContext(method, params) {
-        if (!['message.pull', 'message.v2.pull', 'message.ack', 'message.v2.ack'].includes(method)) {
+        if (!['message.pull', 'message.v2.pull', 'message.history', 'message.ack', 'message.v2.ack', 'message.peers'].includes(method)) {
             return;
         }
         const client = this.runtime.client;
@@ -505,6 +541,19 @@ export class RpcPipeline {
         }
         params.device_id = client._deviceId;
         params.slot_id = client._slotId;
+        if (client._p2pPeerPullEnabled) {
+            if (params.cursor_scope !== undefined && params.cursor_scope !== 'peer')
+                throw new ValidationError('new SDK requires peer cursor_scope');
+            if (params.sender_aid !== undefined)
+                validateAIDFormat(params.sender_aid, 'sender_aid');
+            params.cursor_scope = 'peer';
+            if ((method === 'message.pull' || method === 'message.v2.pull') && params.sender_aid && !('after_volatile_cursor' in params)) {
+                const cursor = client._delivery.peerVolatilePullCursor(String(params.sender_aid));
+                if (cursor)
+                    params.after_volatile_cursor = cursor;
+            }
+            return;
+        }
         if ((method === 'message.pull' || method === 'message.v2.pull') && !('after_volatile_cursor' in params)) {
             const cursor = String(client._delivery.volatilePullCursor?.() ?? '').trim();
             if (cursor)
@@ -610,7 +659,10 @@ export class RpcPipeline {
                 cursor = `after=${String(params.after_seq ?? 0)}`;
             }
             const limit = mode === 'forward' ? (Number(params.limit ?? 50) || 50) : params.limit;
-            return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|volatile=${String(params.after_volatile_cursor ?? '')}|force=${String(Boolean(params.force))}|limit=${String(limit)}`;
+            if (client._p2pPeerPullEnabled && !params.sender_aid)
+                return '';
+            const namespace = client._p2pPeerPullEnabled ? client._delivery.peerNamespace(String(params.sender_aid)) : `p2p:${client._aid}`;
+            return `${namespace}|mode=${mode}|cursor=${cursor}|volatile=${String(params.after_volatile_cursor ?? '')}|force=${String(Boolean(params.force))}|limit=${String(limit)}`;
         }
         if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
             const groupId = String(params.group_id ?? params.group_aid ?? '').trim();
@@ -655,14 +707,15 @@ export class RpcPipeline {
         void key;
         return 'pull';
     }
-    pullGateState(key) {
-        const name = this.pullGateName(key);
+    pullGateState(key, namespaceOnly = false) {
+        const name = namespaceOnly ? 'pull-namespace' : this.pullGateName(key);
         let state = this.pullGateStates.get(name);
         if (!state) {
-            state = { activeByNamespace: new Map(), foreground: [], background: [], byKey: new Map(), lifecycle: new Map(), watchdog: null };
+            state = { networkLimited: !namespaceOnly, activeByNamespace: new Map(), foreground: [], background: [], backgroundPeerDispatches: 0, byKey: new Map(), lifecycle: new Map(), watchdog: null };
             this.pullGateStates.set(name, state);
         }
-        this.startPullGateWatchdog(state, name);
+        if (state.networkLimited)
+            this.startPullGateWatchdog(state, name);
         return state;
     }
     pullGateOperationTimeoutMs() {
@@ -740,9 +793,11 @@ export class RpcPipeline {
     }
     hasPullActivity(namespace, includePending = true) {
         const ns = String(namespace ?? '').trim();
-        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:')) || this.hasInlineRealtimeGuard(ns))
+        if ((!ns.startsWith('p2p:') && !ns.startsWith('p2p.peer.v1/') && !ns.startsWith('group:')) || this.hasInlineRealtimeGuard(ns))
             return true;
         const client = this.runtime.client;
+        if (client._delivery?.hasPeerPageActivity?.(ns))
+            return true;
         if ((client._pullResponseKeys.get(ns) ?? 0) > 0)
             return true;
         if (includePending && Number(client._pendingP2pPullUpper?.get?.(ns) ?? 0) > 0)
@@ -769,7 +824,7 @@ export class RpcPipeline {
     }
     async tryRunInlineRealtime(namespace, seq, operation) {
         const ns = String(namespace ?? '').trim();
-        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:'))
+        if ((!ns.startsWith('p2p:') && !ns.startsWith('p2p.peer.v1/') && !ns.startsWith('group:'))
             || !Number.isSafeInteger(seq) || seq <= 0 || typeof operation !== 'function'
             || this.hasPullActivity(ns)) {
             return { acquired: false };
@@ -780,12 +835,11 @@ export class RpcPipeline {
         }
         finally {
             this.inlineRealtimeScopes.delete(ns);
-            const state = this.pullGateStates.get(this.pullGateName(ns));
-            if (state) {
+            for (const state of this.pullGateStates.values()) {
                 this.drainPullGate(state);
-                this.runtime.client._delivery?.onPullGateIdle?.(ns);
                 this.armQueuedPullTimers(state);
             }
+            this.runtime.client._delivery?.onPullGateIdle?.(ns);
         }
     }
     tryAcquirePullGate(key) {
@@ -825,8 +879,10 @@ export class RpcPipeline {
         const ns = this.pullScopeKey(namespace);
         if (!ns)
             return true;
-        const active = this.pullGateStates.get(this.pullGateName(ns))?.activeByNamespace.get(ns);
-        return !active || active.namespace !== ns || (!active.timedOut && !active.invalidated);
+        return [...this.pullGateStates.values()].every((state) => {
+            const active = state.activeByNamespace.get(ns);
+            return !active || active.namespace !== ns || (!active.timedOut && !active.invalidated);
+        });
     }
     invalidatePulls() {
         if (this.pullInvalidationWait)
@@ -859,6 +915,7 @@ export class RpcPipeline {
             }
             state.foreground = state.foreground.filter((job) => !jobs.has(job));
             state.background = state.background.filter((job) => !jobs.has(job));
+            state.backgroundPeerDispatches = 0;
             for (const [key, job] of state.byKey.entries()) {
                 if (jobs.has(job) && !job.running)
                     state.byKey.delete(key);
@@ -877,7 +934,10 @@ export class RpcPipeline {
     pullInvalidationInProgress() {
         return this.pullInvalidationWait !== null;
     }
-    async runPullSerialized(key, operation, background = false) {
+    async runPullNamespaceSerialized(key, operation, background = false) {
+        return await this.runPullSerialized(key, operation, background, true);
+    }
+    async runPullSerialized(key, operation, background = false, namespaceOnly = false) {
         if (this.runtime.client._dispatcher?._isApplicationHandler?.()) {
             throw new Error('pull cannot wait inside an application handler');
         }
@@ -893,7 +953,7 @@ export class RpcPipeline {
                 throw error;
             }
         }
-        const state = this.pullGateState(key);
+        const state = this.pullGateState(key, namespaceOnly);
         const namespace = this.pullScopeKey(key);
         const active = [...state.activeByNamespace.values()].find((job) => job.key === key && !job.timedOut && !job.invalidated) ?? null;
         const queuedForeground = state.foreground.find((job) => job.key === key && !job.timedOut && !job.invalidated);
@@ -937,7 +997,8 @@ export class RpcPipeline {
         queue.push(job);
         state.byKey.set(key, job);
         this.drainPullGate(state);
-        this.checkPullGate(state, this.pullGateName(key));
+        if (state.networkLimited)
+            this.checkPullGate(state, this.pullGateName(key));
         return await promise;
     }
     async executePullOperation(operation, background) {
@@ -1000,15 +1061,40 @@ export class RpcPipeline {
         state.lifecycle.set(ns, lifecycle);
     }
     drainPullGate(state) {
-        const takeRunnable = (queue) => {
-            const index = queue.findIndex((candidate) => (!this.hasInlineRealtimeGuard(this.pullScopeKey(candidate.key))
-                && !state.activeByNamespace.has(candidate.namespace)));
-            return index >= 0 ? queue.splice(index, 1)[0] : undefined;
+        const peerForward = (job) => job.background && job.namespace.startsWith('p2p.peer.v1/')
+            && job.key.includes('|mode=forward|') && !job.key.includes('|force=true|');
+        const priority = (job) => peerForward(job)
+            ? this.runtime.client._delivery?.peerPullPriority?.(job.namespace) ?? null : null;
+        const runnable = (candidate) => (!this.hasInlineRealtimeGuard(this.pullScopeKey(candidate.key))
+            && !state.activeByNamespace.has(candidate.namespace));
+        const takeRunnable = (queue, background = false) => {
+            let index = queue.findIndex(runnable);
+            if (index < 0)
+                return;
+            if (background && peerForward(queue[index])
+                && (state.backgroundPeerDispatches + 1) % _INTERNAL_MESSAGE_FLOW_LIMITS.pullMaxInflight !== 0) {
+                let best = priority(queue[index]);
+                if (best !== null) {
+                    for (let next = index + 1; next < queue.length; next += 1) {
+                        const hint = priority(queue[next]);
+                        if (hint === null)
+                            break;
+                        if (runnable(queue[next]) && hint < best) {
+                            best = hint;
+                            index = next;
+                        }
+                    }
+                }
+            }
+            const job = queue.splice(index, 1)[0];
+            if (background && peerForward(job))
+                state.backgroundPeerDispatches += 1;
+            return job;
         };
-        while (state.activeByNamespace.size < PULL_GATE_MAX_ACTIVE) {
+        while (state.activeByNamespace.size < _INTERNAL_MESSAGE_FLOW_LIMITS.pullMaxInflight) {
             const foregroundJob = takeRunnable(state.foreground);
             const foregroundDrained = foregroundJob !== undefined && state.foreground.length === 0;
-            const job = foregroundJob ?? takeRunnable(state.background);
+            const job = foregroundJob ?? takeRunnable(state.background, true);
             if (!job)
                 break;
             state.activeByNamespace.set(job.namespace, job);
@@ -1031,7 +1117,7 @@ export class RpcPipeline {
                 continue;
             }
             job.running = true;
-            const operationPromise = this.executePullOperation(job.operation, job.background);
+            const operationPromise = this.executePullOperation(job.operation, state.networkLimited && job.background);
             let failed = false;
             void operationPromise
                 .then((value) => { if (!job.timedOut && !job.invalidated)