@agentunion/fastaun 0.5.33 → 0.5.35

package/dist/client/rpc-pipeline.js

@@ -166,12 +166,16 @@ export class RpcPipeline {
     inlineRealtimeScopes = new Set();
     pullInvalidationWait = null;
     pullDrainedCheckQueued = false;
+    backgroundAcks = new Map();
     constructor(runtime) {
         this.runtime = runtime;
     }
     async call(method, params, assertCurrent, options) {
+        const echoStarted = params && this.runtime.client._echoStarts.get(params);
         if (options?.background !== undefined || options?.deadline !== undefined)
             params = { ...(params ?? {}), ...(options.background !== undefined ? { _rpc_background: options.background, _rpc_foreground: options.background === false } : {}), ...(options.deadline !== undefined ? { _rpc_deadline: options.deadline } : {}) };
+        if (params && echoStarted !== undefined)
+            this.runtime.client._echoStarts.set(params, echoStarted);
         if (method.startsWith('storage.') || method.startsWith('group.fs.')) {
             const { noCache, no_cache, ...wireParams } = params ?? {};
             return storageReadCache(this.runtime.client).rpc(method, wireParams, Boolean(noCache ?? no_cache), (requestParams) => this._call(method, requestParams, undefined, assertCurrent));
@@ -183,9 +187,22 @@ export class RpcPipeline {
     }
     async _call(method, params, onSent, assertCurrent) {
         const client = this.runtime.client;
+        if ((method === 'message.send' || method === 'group.send') && params && client._isEchoPayload(params.payload ?? params.content)) {
+            const started = client._echoStarts.get(params) ?? performance.now();
+            params = { ...params };
+            client._echoStarts.set(params, started);
+        }
         const aid = client._aid, currentAid = client._currentAid;
         const generation = client._delivery?.captureInlineAckGeneration?.();
         const tStart = Date.now();
+        const standbyDeadline = Math.min(typeof params?._rpc_deadline === 'number' ? params._rpc_deadline : Infinity, tStart + (Number(client._sessionOptions?.timeouts?.call ?? 35) * 1000));
+        const standbyRelease = await client._udpStandby?.acquire(method, standbyDeadline);
+        if (client._udpStandby) {
+            const started = params && client._echoStarts.get(params);
+            params = { ...params, _rpc_deadline: standbyDeadline };
+            if (started !== undefined)
+                client._echoStarts.set(params, started);
+        }
         const requestedAckSeq = method === 'message.ack' || method === 'message.v2.ack'
             ? Number(params?.seq
                 ?? params?.up_to_seq
@@ -232,7 +249,7 @@ export class RpcPipeline {
                 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 : []);
+                return await client._v2E2EE.ackPeerV2(sender, requestedAckSeq || undefined, Array.isArray(p.volatile_cursors) ? p.volatile_cursors : [], Array.isArray(p.volatile_ids) ? p.volatile_ids : [], rpcBackground);
             }
             const runWithPullResponseScope = async (operation) => {
                 const scope = pullGateNamespace || (pullGateKey ? this.pullScopeKey(pullGateKey) : '');
@@ -255,6 +272,19 @@ export class RpcPipeline {
                     ? this.runPullNamespaceSerialized.bind(this) : this.runPullSerialized.bind(this);
                 return await run(pullGateKey, async () => this.call(method, lockedParams), pullBackground);
             }
+            if (method === 'message.send' || method === 'group.send') {
+                const echo = client._isEchoPayload(p.payload);
+                const stopped = client._maybeAppendEchoTraceSend(p);
+                if (echo) {
+                    p.encrypt = false;
+                    delete p.encrypted;
+                }
+                if (stopped) {
+                    const result = { status: 'echo_return', message_id: p.message_id, from: p.to ?? p.group_id ?? client._aid, to: client._aid, ...(p.group_id ? { group_id: p.group_id } : {}), payload: p.payload };
+                    await client._publishEchoReturn(method, p, result);
+                    return result;
+                }
+            }
             if (method === 'message.send') {
                 const encrypt = p.encrypt ?? true;
                 delete p.encrypt;
@@ -272,7 +302,6 @@ export class RpcPipeline {
                         deadline,
                     }));
                 }
-                client._maybeAppendEchoTraceSend(p);
             }
             if (method === 'group.send') {
                 const encrypt = p.encrypt ?? true;
@@ -291,7 +320,6 @@ export class RpcPipeline {
                         deadline,
                     }));
                 }
-                client._maybeAppendEchoTraceSend(p);
             }
             if (method === 'group.thought.put') {
                 const encrypt = p.encrypt ?? true;
@@ -324,6 +352,7 @@ export class RpcPipeline {
                     gateLocked: true,
                     force,
                     afterVolatileCursor: String(p.after_volatile_cursor ?? '').trim() || undefined,
+                    background: Boolean(rpcBackground),
                 })));
                 return { messages };
             }
@@ -415,18 +444,30 @@ export class RpcPipeline {
                 this.applyClientSignature(method, p);
                 assertCurrent?.();
                 const transportParams = deadline === undefined ? p : { ...p, _rpc_deadline: deadline };
-                const request = onSent
-                    ? client._transport['_callWithSent'](method, transportParams, onSent, remaining, undefined, rpcBackground)
-                    : remaining !== undefined
-                        ? (rpcBackground
-                            ? client._transport.call(method, transportParams, remaining, undefined, rpcBackground)
-                            : client._transport.call(method, transportParams, remaining))
-                        : (rpcBackground
-                            ? client._transport.call(method, transportParams, undefined, undefined, rpcBackground)
-                            : client._transport.call(method, transportParams));
+                const history = !onSent && client._historyChannels?.().isHistory(method, transportParams, rpcBackground);
+                const request = history
+                    ? client._historyChannels().call(method, transportParams, remaining, undefined, rpcBackground, (prepared) => this.applyClientSignature(method, prepared))
+                    : onSent
+                        ? client._transport['_callWithSent'](method, transportParams, onSent, remaining, undefined, rpcBackground)
+                        : remaining !== undefined
+                            ? (rpcBackground
+                                ? client._transport.call(method, transportParams, remaining, undefined, rpcBackground)
+                                : client._transport.call(method, transportParams, remaining))
+                            : (rpcBackground
+                                ? client._transport.call(method, transportParams, undefined, undefined, rpcBackground)
+                                : client._transport.call(method, transportParams));
                 return this.bindActivePullCancellation(method, p, request);
             };
-            let result = await this.transportCallWithIdentityRecovery(invokeTransport, method, p);
+            let result;
+            try {
+                result = await this.transportCallWithIdentityRecovery(invokeTransport, method, p);
+            }
+            catch (error) {
+                const returned = await client._echoFailure(method, p, error, true);
+                if (returned)
+                    return returned;
+                throw error;
+            }
             invalidateStorageReadCache(client, method, p);
             if (generation === client._delivery?.captureInlineAckGeneration?.()) {
                 if (method === 'group.unblock' && aid && client._aid === aid && client._currentAid === currentAid
@@ -439,6 +480,7 @@ export class RpcPipeline {
             result = await this.postprocessResult(method, p, result, {
                 skipGroupState: deferGroupReadyPostprocess,
                 pullNamespace: pullGateNamespace,
+                background: Boolean(rpcBackground),
             });
             if (!skipSendResultEnvelope) {
                 result = client._delivery.attachSendResultEnvelope(method, p, result, Boolean(p.encrypted), sendResultModeSource);
@@ -451,6 +493,7 @@ export class RpcPipeline {
             throw err;
         }
         finally {
+            standbyRelease?.();
             if (generation === client._delivery?.captureInlineAckGeneration?.())
                 client._delivery?.requestBackgroundPullRecovery?.();
         }
@@ -464,6 +507,8 @@ export class RpcPipeline {
             throw new PermissionError(`method is internal_only: ${method}`);
         }
         const p = { ...(params ?? {}) };
+        if (params && client._echoStarts.has(params))
+            client._echoStarts.set(p, client._echoStarts.get(params));
         this.mergeInstanceProtectedHeaders(method, p);
         const requestedBackground = p._rpc_background ?? p._rpc_background_kind;
         const rpcBackground = p._rpc_foreground === true ? false
@@ -913,6 +958,19 @@ export class RpcPipeline {
             return false;
         return (this.runtime.client._pullResponseKeys.get(this.pullScopeKey(key)) ?? 0) > 0;
     }
+    pendingHistoryNamespaces() {
+        const namespaces = new Set();
+        for (const state of this.pullGateStates.values())
+            for (const job of state.background) {
+                if (job.invalidated || job.timedOut || /(?:mode=history|mode=tail|\|tail\||tail=true|volatile=true|force=true|class=(?:control|sdk_control))/.test(job.key))
+                    continue;
+                if ((this.runtime.client._delivery?.automaticPullRetryAt?.(job.namespace, job.operation) ?? 0) > Date.now())
+                    continue;
+                if (job.namespace.startsWith('p2p:') || job.namespace.startsWith('p2p.peer.v1/') || job.namespace.startsWith('group:') || job.namespace.startsWith('group_event:'))
+                    namespaces.add(job.namespace);
+            }
+        return [...namespaces];
+    }
     hasPullActivity(namespace, includePending = true) {
         const ns = String(namespace ?? '').trim();
         if ((!ns.startsWith('p2p:') && !ns.startsWith('p2p.peer.v1/') && !ns.startsWith('group:') && !ns.startsWith('message_class/')) || this.hasInlineRealtimeGuard(ns))
@@ -1313,6 +1371,98 @@ export class RpcPipeline {
     armQueuedPullTimers(_state) { }
     // ── raw-call ───────────────────────────────────────────────────────────────
     async rawCall(method, params, opts = {}) {
+        const client = this.runtime.client;
+        const deadline = Math.min(typeof params?._rpc_deadline === 'number' ? params._rpc_deadline : Infinity, Date.now() + (opts.timeout ?? Number(client._sessionOptions?.timeouts?.call ?? 35) * 1000));
+        const release = await client._udpStandby?.acquire(method, deadline);
+        try {
+            return await this.rawCallAdmitted(method, client._udpStandby ? { ...params, _rpc_deadline: deadline } : params, opts);
+        }
+        finally {
+            release?.();
+        }
+    }
+    async rawCallAdmitted(method, params, opts = {}) {
+        const client = this.runtime.client;
+        const peerAck = method === 'message.ack' && params?.cursor_scope === 'peer';
+        if (peerAck && params?.seq !== undefined) {
+            params = { ...params, up_to_seq: Object.hasOwn(params, 'up_to_seq') ? params.up_to_seq : params.seq };
+            delete params.seq;
+        }
+        const background = params?._rpc_foreground === true ? false : opts.background ?? params?._rpc_background ?? params?._rpc_background_kind;
+        const field = peerAck ? 'up_to_seq' : { 'message.ack': 'seq', 'message.v2.ack': 'up_to_seq', 'group.ack_messages': 'msg_seq', 'group.v2.ack': 'up_to_seq', 'group.ack_events': 'event_seq' }[method];
+        const seq = field ? params?.[field] : undefined;
+        if (!background || !field || typeof seq !== 'number' || !Number.isSafeInteger(seq) || seq <= 0
+            || Object.keys(params ?? {}).some(key => /volatile|token|proof/.test(key)))
+            return this.rawCallDirect(method, params, opts);
+        const scope = () => [client._aid, client._currentAid, client._deviceId, client._slotId, client._gatewayConnectionId,
+            client._delivery?.captureInlineAckGeneration?.(), client._transport, client._transport?._connectionGeneration, client._transport?._workerGeneration];
+        const identity = scope();
+        const range = { ...params };
+        delete range[field];
+        delete range._rpc_deadline;
+        const key = stableStringify([method, range, opts]);
+        const waitForResponse = (active) => new Promise((resolve, reject) => {
+            let timer;
+            const waiter = { seq, params: { ...params }, resolve: (value) => { clearTimeout(timer); resolve(value); },
+                reject: (error) => { clearTimeout(timer); reject(error); } };
+            active.waiters.push(waiter);
+            const timeout = opts.timeout ?? client._transport?._timeout;
+            const deadline = typeof params?._rpc_deadline === 'number' ? params._rpc_deadline : Infinity;
+            const remaining = Math.min(typeof timeout === 'number' ? timeout : Infinity, deadline - Date.now());
+            if (Number.isFinite(remaining))
+                timer = setTimeout(() => {
+                    active.waiters = active.waiters.filter(item => item !== waiter);
+                    waiter.reject(new TimeoutError(`rpc timeout: ${method}`, { retryable: true }));
+                }, Math.max(0, remaining));
+        });
+        let job = this.backgroundAcks.get(key);
+        if (job && !job.scope.every((value, index) => value === identity[index]))
+            job = undefined;
+        if (job) {
+            return waitForResponse(job);
+        }
+        job = { scope: identity, params: { ...params }, waiters: [] };
+        const active = job;
+        const response = waitForResponse(active);
+        this.backgroundAcks.set(key, active);
+        const assertCurrent = () => {
+            const currentScope = scope();
+            if (!active.scope.every((value, index) => value === currentScope[index]))
+                throw new ConnectionError('ACK context changed');
+        };
+        void (async () => {
+            try {
+                while (active.waiters.length > 0) {
+                    assertCurrent();
+                    const latest = active.waiters.reduce((highest, waiter) => waiter.seq > highest.seq ? waiter : highest);
+                    const requested = latest.seq;
+                    try {
+                        const result = await this.rawCallDirect(method, { ...latest.params, [field]: requested }, opts, assertCurrent);
+                        const covered = active.waiters.filter(waiter => waiter.seq <= requested);
+                        active.waiters = active.waiters.filter(waiter => waiter.seq > requested);
+                        for (const waiter of covered)
+                            waiter.resolve(result);
+                    }
+                    catch (error) {
+                        const covered = active.waiters.filter(waiter => waiter.seq <= requested);
+                        active.waiters = active.waiters.filter(waiter => waiter.seq > requested);
+                        for (const waiter of covered)
+                            waiter.reject(error);
+                    }
+                }
+            }
+            catch (error) {
+                for (const waiter of active.waiters)
+                    waiter.reject(error);
+            }
+            finally {
+                if (this.backgroundAcks.get(key) === active)
+                    this.backgroundAcks.delete(key);
+            }
+        })();
+        return response;
+    }
+    async rawCallDirect(method, params, opts = {}, assertCurrent) {
         const { timeout, trace, signed = true, background = false, pullGateKey = '' } = opts;
         const client = this.runtime.client;
         if (client._migrationPending)
@@ -1330,8 +1480,11 @@ export class RpcPipeline {
             this.applyClientSignature(method, payload);
         }
         const invokeTransport = () => {
+            assertCurrent?.();
             let request;
-            if (rpcBackground)
+            if (client._historyChannels?.().isHistory(method, payload, rpcBackground))
+                request = client._historyChannels().call(method, payload, timeout, trace, rpcBackground, signed ? (prepared) => this.applyClientSignature(method, prepared) : undefined);
+            else if (rpcBackground)
                 request = client._transport.call(method, payload, timeout, trace, rpcBackground);
             else if (trace !== undefined)
                 request = client._transport.call(method, payload, timeout, trace);
@@ -1364,7 +1517,7 @@ export class RpcPipeline {
         }
     }
     observeBackgroundPullResponse(method, params, result, key = '') {
-        if (params.message_class !== undefined && params.message_class !== 'normal' || params.volatile === true)
+        if (params.message_class !== undefined && params.message_class !== 'normal' || params.volatile === true || params.storage_scope === 'volatile')
             return;
         if (!['message.pull', 'message.v2.pull', 'group.pull', 'group.v2.pull', 'group.pull_events'].includes(method)
             || params.force === true || params.window_mode === 'tail')
@@ -1418,59 +1571,70 @@ export class RpcPipeline {
     // ── postprocess ────────────────────────────────────────────────────────────
     async postprocessResult(method, params, result, options = {}) {
         const client = this.runtime.client;
-        const pullNamespace = this.pullScopeKey(options.pullNamespace || this.pullGateKeyForCall(method, params));
-        this.throwIfPullInvalidated(pullNamespace);
-        let next = result;
-        if ((method === 'group.send' || method === 'group.v2.send') && isUnknownJsonObject(next)) {
-            next = normalizeGroupMentionMode(next);
-        }
-        if (method === 'group.get_settings' || method === 'group.set_settings') {
-            next = normalizeGroupSettingsResponse(next);
-        }
-        if (method === 'group.thought.get' && isUnknownJsonObject(next)) {
-            client._clientLog?.debug?.(`group.thought.get transport result: found=${String(next.found ?? '')}, raw_count=${Array.isArray(next.thoughts) ? next.thoughts.length : 0}`);
-            next = await client._decryptGroupThoughts(next);
-        }
-        if (method === 'message.thought.get' && isUnknownJsonObject(next)) {
-            client._clientLog?.debug?.(`message.thought.get transport result: found=${String(next.found ?? '')}, raw_count=${Array.isArray(next.thoughts) ? next.thoughts.length : 0}`);
-            next = await client._decryptMessageThoughts(next);
-        }
-        if (method === 'message.pull' && isUnknownJsonObject(next)) {
-            const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
-            if (!isTail && client._aid && client._seqTracker) {
-                const ns = pullNamespace || `p2p:${client._aid}`;
-                const afterSeq = Math.max(0, Number(params.after_seq ?? 0) || 0);
-                await client._delivery.commitPlainForwardPage(ns, afterSeq, 'message.pull', next);
-            }
-            else {
-                this.postprocessMessagePull(params, next);
-            }
-        }
-        if (method === 'group.pull' && isUnknownJsonObject(next)) {
-            if (Array.isArray(next.messages)) {
-                next.messages = next.messages.map((message) => normalizeGroupMentionMode(message));
-            }
-            const gid = String(params.group_id ?? params.group_aid ?? '').trim();
-            const explicitCursorParams = this.explicitGroupCursorParams(params);
-            const ownsCursor = Object.keys(explicitCursorParams).length === 0
-                || this.groupCursorTargetsCurrentInstance(explicitCursorParams);
-            const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
-            if (!ownsCursor) {
-                client._clientLog.debug(`group.pull external cursor skips local Forward commit: group=${gid}`);
+        try {
+            const pullNamespace = this.pullScopeKey(options.pullNamespace || this.pullGateKeyForCall(method, params));
+            this.throwIfPullInvalidated(pullNamespace);
+            let next = result;
+            if ((method === 'message.send' || method === 'group.send') && next && typeof next === 'object'
+                && next.status === 'echo_return') {
+                await client._publishEchoReturn(method, params, next);
+                return next;
+            }
+            if ((method === 'group.send' || method === 'group.v2.send') && isUnknownJsonObject(next)) {
+                next = normalizeGroupMentionMode(next);
+            }
+            if (method === 'group.get_settings' || method === 'group.set_settings') {
+                next = normalizeGroupSettingsResponse(next);
+            }
+            if (method === 'group.thought.get' && isUnknownJsonObject(next)) {
+                client._clientLog?.debug?.(`group.thought.get transport result: found=${String(next.found ?? '')}, raw_count=${Array.isArray(next.thoughts) ? next.thoughts.length : 0}`);
+                next = await client._decryptGroupThoughts(next);
+            }
+            if (method === 'message.thought.get' && isUnknownJsonObject(next)) {
+                client._clientLog?.debug?.(`message.thought.get transport result: found=${String(next.found ?? '')}, raw_count=${Array.isArray(next.thoughts) ? next.thoughts.length : 0}`);
+                next = await client._decryptMessageThoughts(next);
+            }
+            if (method === 'message.pull' && isUnknownJsonObject(next)) {
+                const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+                if (!isTail && client._aid && client._seqTracker) {
+                    const ns = pullNamespace || `p2p:${client._aid}`;
+                    const afterSeq = Math.max(0, Number(params.after_seq ?? 0) || 0);
+                    await client._delivery.commitPlainForwardPage(ns, afterSeq, 'message.pull', next, '', options.background === true);
+                }
+                else {
+                    this.postprocessMessagePull(params, next);
+                }
             }
-            else if (!isTail && gid && client._seqTracker) {
-                const ns = pullNamespace || `group:${gid}`;
-                const afterSeq = Math.max(0, Number(params.after_message_seq ?? params.after_seq ?? 0) || 0);
-                await client._delivery.commitPlainForwardPage(ns, afterSeq, 'group.pull', next, gid);
+            if (method === 'group.pull' && isUnknownJsonObject(next)) {
+                if (Array.isArray(next.messages)) {
+                    next.messages = next.messages.map((message) => normalizeGroupMentionMode(message));
+                }
+                const gid = String(params.group_id ?? params.group_aid ?? '').trim();
+                const explicitCursorParams = this.explicitGroupCursorParams(params);
+                const ownsCursor = Object.keys(explicitCursorParams).length === 0
+                    || this.groupCursorTargetsCurrentInstance(explicitCursorParams);
+                const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+                if (!ownsCursor) {
+                    client._clientLog.debug(`group.pull external cursor skips local Forward commit: group=${gid}`);
+                }
+                else if (!isTail && gid && client._seqTracker) {
+                    const ns = pullNamespace || `group:${gid}`;
+                    const afterSeq = Math.max(0, Number(params.after_message_seq ?? params.after_seq ?? 0) || 0);
+                    await client._delivery.commitPlainForwardPage(ns, afterSeq, 'group.pull', next, gid, options.background === true);
+                }
+                else {
+                    this.postprocessGroupPull(params, next);
+                }
             }
-            else {
-                this.postprocessGroupPull(params, next);
+            if (!options.skipGroupState) {
+                next = await client._groupState.postprocessResult(method, params, next);
             }
+            return next;
         }
-        if (!options.skipGroupState) {
-            next = await client._groupState.postprocessResult(method, params, next);
+        finally {
+            if (method === 'message.pull' || method === 'group.pull')
+                client._syncChannelCoordinator?.releaseResponse(result);
         }
-        return next;
     }
     // ── private helpers ────────────────────────────────────────────────────────
     postprocessMessagePull(params, result) {