@agentunion/fastaun 0.5.32 → 0.5.34

package/dist/client/rpc-pipeline.js

@@ -166,6 +166,7 @@ export class RpcPipeline {
     inlineRealtimeScopes = new Set();
     pullInvalidationWait = null;
     pullDrainedCheckQueued = false;
+    backgroundAcks = new Map();
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -232,7 +233,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) : '');
@@ -415,15 +416,18 @@ 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);
@@ -528,14 +532,30 @@ export class RpcPipeline {
             throw new ValidationError('message_class must be normal, control or sdk_control');
         }
         if (['message.send', 'group.send', 'group.v2.send'].includes(method)) {
-            const messageClass = Object.hasOwn(params, 'message_class') ? params.message_class : 'normal';
+            let messageClass = Object.hasOwn(params, 'message_class') ? params.message_class : 'normal';
             if (typeof messageClass !== 'string' || !['normal', 'control', 'sdk_control'].includes(messageClass)) {
                 throw new ValidationError('message_class must be normal, control or sdk_control');
             }
+            const classes = this.runtime.client._negotiatedCapabilities?.message_classes_v2?.[method.startsWith('group.') ? 'group' : 'p2p'];
+            if (messageClass === 'control' && (!Array.isArray(classes) || !classes.includes('control'))) {
+                const protectedHeaders = this.runtime.client._protectedHeadersFromParams(params) ?? {};
+                if (protectedHeaders.message_class !== undefined && protectedHeaders.message_class !== messageClass) {
+                    throw new ValidationError('protected message_class differs from the requested class');
+                }
+                delete params.message_class;
+                for (const field of ['protected_headers', 'headers']) {
+                    if (isJsonObject(params[field])) {
+                        const headers = { ...params[field] };
+                        delete headers.message_class;
+                        params[field] = headers;
+                    }
+                }
+                messageClass = 'normal';
+            }
             if (method.startsWith('group.') && messageClass === 'sdk_control') {
                 throw new StateError('SDK control messages are not supported for groups', { stringCode: 'unsupported_protocol' });
             }
-            if (method.startsWith('group.') && Number(params.ttl) > 0
+            if (method.startsWith('group.') && messageClass !== 'normal' && Number(params.ttl) > 0
                 && !this.runtime.client._controlMessages().supports(messageClass, true)) {
                 throw new StateError('volatile group delivery protocol has not been negotiated', { stringCode: 'unsupported_protocol' });
             }
@@ -546,6 +566,9 @@ export class RpcPipeline {
                 }
                 params.protected_headers = { ...protectedHeaders, message_class: messageClass };
                 if (messageClass === 'sdk_control') {
+                    if (params.encrypt === false && (!isJsonObject(params.payload) || params.payload.type !== 'e2ee.p2p_encrypted')) {
+                        throw new ValidationError('SDK control messages require E2EE');
+                    }
                     const negotiated = this.runtime.client._negotiatedCapabilities ?? {};
                     const scope = method.startsWith('group.') ? 'group' : 'p2p';
                     const classes = negotiated.message_classes_v2?.[scope];
@@ -556,9 +579,12 @@ export class RpcPipeline {
                         throw new ValidationError('protected SDK control protocol differs from the request');
                     }
                     params.protected_headers = { ...params.protected_headers, sdk_control_protocol: protocol, sdk_control_version: version };
-                    if (!Array.isArray(classes) || !classes.includes('sdk_control') || !protocol || !Number.isSafeInteger(version)
-                        || typeof protocol !== 'string' || !Array.isArray(negotiated.sdk_control_protocols?.[protocol]) || !negotiated.sdk_control_protocols[protocol].includes(version)) {
-                        throw new StateError('SDK control protocol has not been negotiated', { stringCode: 'unsupported_protocol' });
+                    if (!protocol || typeof protocol !== 'string' || !Number.isSafeInteger(version) || Number(version) <= 0) {
+                        throw new ValidationError('SDK control requires a protocol and positive integer version');
+                    }
+                    if (!Array.isArray(classes) || !classes.includes('sdk_control')
+                        || !Array.isArray(negotiated.sdk_control_protocols?.[protocol]) || !negotiated.sdk_control_protocols[protocol].includes(version)) {
+                        delete params.message_class;
                     }
                 }
             }
@@ -891,6 +917,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))
@@ -1291,6 +1330,86 @@ export class RpcPipeline {
     armQueuedPullTimers(_state) { }
     // ── raw-call ───────────────────────────────────────────────────────────────
     async rawCall(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];
+        const key = stableStringify([method, range, opts]);
+        const waitForResponse = (active) => new Promise((resolve, reject) => {
+            let timer;
+            const waiter = { seq, 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, { ...active.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)
@@ -1308,8 +1427,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);
@@ -1342,7 +1464,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')
@@ -1396,59 +1518,65 @@ 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 === '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);
+                }
             }
-            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);
+                }
+                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) {