@agentunion/fastaun-browser 0.5.8 → 0.5.10

package/dist/client/rpc-pipeline.js

@@ -19,6 +19,15 @@ const PROTECTED_HEADERS_METHODS = new Set([
     'message.thought.put',
     'group.thought.put',
 ]);
+function generateMessageId() {
+    if (typeof crypto.randomUUID === 'function')
+        return `m-${crypto.randomUUID().replace(/-/g, '')}`;
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return `m-${Array.from(bytes, (value) => value.toString(16).padStart(2, '0')).join('')}`;
+}
 const SIGNED_METHODS = new Set([
     'message.send',
     'message.v2.put_peer_pk', 'message.v2.bootstrap',
@@ -71,6 +80,7 @@ const SIGNED_METHODS = new Set([
     'group.dissolve', 'group.suspend', 'group.resume',
 ]);
 const SIGNING_KEY_CACHE_MAX = 32;
+const IDENTITY_ADMISSION_RETRY_DELAYS_MS = [0, 50, 100, 200];
 const signingKeyCache = new Map();
 const certFingerprintCache = new Map();
 function cacheGet(cache, key) {
@@ -120,6 +130,13 @@ async function signingCertFingerprint(certPem) {
 }
 const PULL_GATE_STALE_MS = 30000;
 const PULL_GATE_OPERATION_TIMEOUT_MS = 3000;
+function sameIdentityAdmissionRejection(error, original) {
+    const errorCode = Number(error?.code);
+    const originalCode = Number(original?.code);
+    const errorMessage = String(error instanceof Error ? error.message : error?.message ?? '').trim().toLowerCase();
+    const originalMessage = String(original instanceof Error ? original.message : original?.message ?? '').trim().toLowerCase();
+    return errorCode === -32003 && originalCode === -32003 && errorMessage === originalMessage;
+}
 const NON_IDEMPOTENT_TIMEOUT = 35;
 const NON_IDEMPOTENT_METHODS = new Set([
     'message.send', 'mail.send', 'group.send', 'group.create', 'group.invite',
@@ -170,6 +187,9 @@ export class RpcPipeline {
     runtime;
     pullGateStates = new Map();
     inlineRealtimeScopes = new Set();
+    pullWorkTokens = new Set();
+    pullGeneration = 0;
+    pullInvalidationWait = null;
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -359,6 +379,9 @@ export class RpcPipeline {
         delete p._rpc_background;
         if (method === 'message.send' || method === 'group.send') {
             this.normalizeOutboundMessagePayload(p, method);
+            if (!Object.prototype.hasOwnProperty.call(p, 'message_id') || p.message_id == null) {
+                p.message_id = generateMessageId();
+            }
         }
         this.normalizeGroupCallIdentifier(method, p);
         this.validateOutboundCall(method, p);
@@ -539,8 +562,8 @@ export class RpcPipeline {
             const mode = method === 'message.history' ? 'history' : params.window_mode === 'tail' ? 'tail' : 'forward';
             const cursor = mode === 'history'
                 ? `before=${String(params.before_seq)}`
-                : `after=${String(params.after_seq ?? 0)}|force=${String(Boolean(params.force))}`;
-            return `p2p:${client._aid}|${mode}|${cursor}|limit=${String(params.limit)}`;
+                : `after=${String(params.after_seq ?? 0)}`;
+            return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|force=${String(Boolean(params.force))}|limit=${String(params.limit)}`;
         }
         if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
             const gid = String(params.group_id ?? params.group_aid ?? '').trim();
@@ -549,13 +572,17 @@ export class RpcPipeline {
             const mode = method === 'group.history' ? 'history' : params.window_mode === 'tail' ? 'tail' : 'forward';
             const cursor = mode === 'history'
                 ? `before=${String(params.before_seq)}`
-                : `after=${String(params.after_seq ?? params.after_message_seq ?? 0)}|force=${String(Boolean(params.force))}`;
-            return `group:${gid}|${mode}|${cursor}|limit=${String(params.limit)}`;
+                : `after=${String(params.after_seq ?? params.after_message_seq ?? 0)}`;
+            const explicitCursor = this.explicitGroupCursorParams(params);
+            const cursorSuffix = Object.keys(explicitCursor).length > 0
+                ? `|cursor_params=${stableStringify(explicitCursor)}`
+                : '';
+            return `group:${gid}|mode=${mode}|cursor=${cursor}${cursorSuffix}|force=${String(Boolean(params.force))}|limit=${String(params.limit)}`;
         }
         if (method === 'group.pull_events') {
             const gid = String(params.group_id ?? params.group_aid ?? '').trim();
             return gid
-                ? `group_event:${gid}|forward|after=${String(params.after_event_seq ?? 0)}|limit=${String(params.limit)}`
+                ? `group_event:${gid}|mode=forward|cursor=after=${String(params.after_event_seq ?? 0)}|force=${String(Boolean(params.force))}|limit=${String(params.limit)}`
                 : '';
         }
         return '';
@@ -578,8 +605,8 @@ export class RpcPipeline {
         if (!state) {
             state = { active: null, foreground: [], background: [], byKey: new Map(), lifecycle: new Map(), watchdog: null };
             this.pullGateStates.set(name, state);
-            this.startPullGateWatchdog(state, name);
         }
+        this.startPullGateWatchdog(state, name);
         return state;
     }
     pullGateOperationTimeoutMs() {
@@ -597,6 +624,14 @@ export class RpcPipeline {
         state.watchdog = timer;
         timer.unref?.();
     }
+    stopPullGateWatchdogs() {
+        for (const state of this.pullGateStates.values()) {
+            if (state.watchdog === null)
+                continue;
+            clearInterval(state.watchdog);
+            state.watchdog = null;
+        }
+    }
     checkPullGate(state, name) {
         const active = state.active;
         if (!active) {
@@ -608,18 +643,12 @@ export class RpcPipeline {
         if (active.timedOut)
             return;
         active.timedOut = true;
+        active.invalidated = true;
+        this.pullGeneration += 1;
         active.cancel?.();
         const err = new TimeoutError(`pull gate timeout: ${active.namespace}`, { retryable: true });
         this.runtime.client._clientLog?.warn(`pull gate watchdog timeout: gate=${name} key=${active.key}`);
-        state.lifecycle.set(active.namespace, 'idle');
-        if (state.active === active)
-            state.active = null;
-        if (state.byKey.get(active.key) === active)
-            state.byKey.delete(active.key);
-        active.resolve = () => { };
         active.reject(err);
-        this.drainPullGate(state);
-        this.runtime.client._delivery?.onPullGateIdle?.(active.namespace);
     }
     realtimePullNamespace(key) {
         for (const marker of ['|tail|', '|forward|']) {
@@ -640,7 +669,7 @@ export class RpcPipeline {
             return request;
         const state = this.pullGateStates.get(this.pullGateName(key));
         const active = state?.active;
-        if (!active || active.namespace !== this.pullScopeKey(key) || active.timedOut)
+        if (!active || active.key !== key || active.timedOut || active.invalidated)
             return request;
         const boundCancel = () => cancel.call(request);
         active.cancel = boundCancel;
@@ -706,6 +735,32 @@ export class RpcPipeline {
         const matches = (job) => job !== null && job.namespace === ns;
         return matches(state.active) || state.foreground.some(matches) || state.background.some(matches);
     }
+    hasAnyPullActivity() {
+        if (this.pullWorkTokens.size > 0)
+            return true;
+        for (const state of this.pullGateStates.values()) {
+            if (state.active || state.foreground.length > 0 || state.background.length > 0)
+                return true;
+        }
+        return false;
+    }
+    reservePullWork() {
+        const token = Symbol('pull-work');
+        this.pullWorkTokens.add(token);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.pullWorkTokens.delete(token);
+            this.runtime.client._delivery?.onPullWorkSettled?.();
+        };
+    }
+    releasePullWorkToken(token) {
+        if (!this.pullWorkTokens.delete(token))
+            return;
+        this.runtime.client._delivery?.onPullWorkSettled?.();
+    }
     async tryRunInlineRealtime(ns, seq, operation) {
         const normalized = String(ns ?? '').trim();
         if ((!normalized.startsWith('p2p:') && !normalized.startsWith('group:'))
@@ -744,7 +799,11 @@ export class RpcPipeline {
             resumeResolve: null,
             pullingStartedAt: 0,
             timedOut: false,
+            invalidated: false,
             cancel: null,
+            settled: Promise.resolve(),
+            settledResolve: null,
+            workToken: Symbol('inline-pull-work'),
         };
         this.inlineRealtimeScopes.add(normalized);
         try {
@@ -791,17 +850,77 @@ export class RpcPipeline {
         gate.inflight = false;
         gate.startedAt = 0;
     }
+    isPullGenerationCurrent(generation) {
+        return generation === this.pullGeneration;
+    }
+    invalidatePulls() {
+        if (this.pullInvalidationWait)
+            return this.pullInvalidationWait;
+        this.pullGeneration += 1;
+        const error = new Error('pull invalidated');
+        const waits = [];
+        for (const state of this.pullGateStates.values()) {
+            const jobs = new Set();
+            if (state.active)
+                jobs.add(state.active);
+            for (const job of state.foreground)
+                jobs.add(job);
+            for (const job of state.background)
+                jobs.add(job);
+            for (const job of jobs) {
+                job.invalidated = true;
+                if (!job.timedOut)
+                    job.reject(error);
+                job.cancel?.();
+                job.resumeResolve?.();
+                job.resumeResolve = null;
+                if (job.running) {
+                    waits.push(job.settled);
+                }
+                else {
+                    this.releasePullWorkToken(job.workToken);
+                    job.settledResolve?.();
+                    job.settledResolve = null;
+                }
+            }
+            state.foreground = state.foreground.filter((job) => !jobs.has(job));
+            state.background = state.background.filter((job) => !jobs.has(job));
+            for (const [key, job] of state.byKey.entries()) {
+                if (jobs.has(job) && !job.running)
+                    state.byKey.delete(key);
+            }
+            this.drainPullGate(state);
+        }
+        const wait = Promise.all(waits).then(() => undefined);
+        this.runtime.client._delivery?.onPullWorkSettled?.();
+        let tracked;
+        tracked = wait.finally(() => {
+            if (this.pullInvalidationWait === tracked)
+                this.pullInvalidationWait = null;
+        });
+        this.pullInvalidationWait = tracked;
+        return tracked;
+    }
+    pullInvalidationInProgress() {
+        return this.pullInvalidationWait !== null;
+    }
     async runPullSerialized(key, operation, background = false) {
-        if (!key)
-            return await this.executePullOperation(operation, background);
+        if (this.pullInvalidationInProgress()) {
+            throw new Error('pull invalidated');
+        }
+        if (!key) {
+            const releasePullWork = this.reservePullWork();
+            try {
+                return await this.executePullOperation(operation, background);
+            }
+            finally {
+                releasePullWork();
+            }
+        }
         const state = this.pullGateState(key);
         const namespace = this.pullScopeKey(key);
-        const active = state.active?.namespace === namespace ? state.active : null;
-        const queuedForeground = state.foreground.find((job) => job.namespace === namespace);
-        const queuedBackground = state.background.find((job) => job.namespace === namespace);
-        const existing = background
-            ? (active ?? queuedForeground ?? queuedBackground)
-            : (queuedForeground ?? (active && !active.background ? active : null) ?? queuedBackground);
+        const candidate = state.byKey.get(key);
+        const existing = candidate && !candidate.timedOut && !candidate.invalidated ? candidate : null;
         if (existing) {
             if (!background && existing.background && existing !== state.active) {
                 const index = state.background.indexOf(existing);
@@ -812,16 +931,24 @@ export class RpcPipeline {
             }
             return await existing.promise;
         }
+        const workToken = Symbol('pull-work');
+        this.pullWorkTokens.add(workToken);
         let resolve;
         let reject;
+        let settledResolve;
         const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+        const settled = new Promise((resolveSettled) => { settledResolve = resolveSettled; });
         void promise.catch(() => { });
         const job = {
             key, namespace, background, running: false, suspended: false, operation, promise, resolve, reject, timer: null,
             resume: null, resumeResolve: null,
             pullingStartedAt: 0,
             timedOut: false,
+            invalidated: false,
             cancel: null,
+            settled,
+            settledResolve,
+            workToken,
         };
         (background ? state.background : state.foreground).push(job);
         state.byKey.set(key, job);
@@ -830,18 +957,36 @@ export class RpcPipeline {
         return await promise;
     }
     async executePullOperation(operation, background) {
-        if (background)
-            return await this.runtime.client._withBackgroundRpc(operation);
-        return await operation();
+        const client = this.runtime.client;
+        const hadPrevious = Object.prototype.hasOwnProperty.call(client, '_pullOperationGeneration');
+        const previous = client._pullOperationGeneration;
+        client._pullOperationGeneration = this.pullGeneration;
+        try {
+            if (background)
+                return await client._withBackgroundRpc(operation);
+            return await operation();
+        }
+        finally {
+            if (hadPrevious)
+                client._pullOperationGeneration = previous;
+            else
+                delete client._pullOperationGeneration;
+        }
+    }
+    pullOperationIsCurrent() {
+        const generation = this.runtime.client._pullOperationGeneration;
+        return generation === undefined || this.isPullGenerationCurrent(generation);
+    }
+    throwIfPullInvalidated() {
+        if (!this.pullOperationIsCurrent())
+            throw new Error('pull invalidated');
     }
     async yieldPullGate(key, nextKey, background) {
         if (!key)
             return;
         const state = this.pullGateState(key);
         const namespace = this.pullScopeKey(key);
-        const job = state.active?.namespace === namespace
-            ? state.active
-            : [...state.foreground, ...state.background].find((candidate) => candidate.namespace === namespace);
+        const job = state.active?.key === key ? state.active : null;
         if (!job || state.active !== job)
             return;
         const replacementKey = String(nextKey || key);
@@ -858,8 +1003,11 @@ export class RpcPipeline {
         state.active = null;
         (job.background ? state.background : state.foreground).push(job);
         this.drainPullGate(state);
-        if (job.resume)
+        if (job.resume) {
             await job.resume;
+            if (job.invalidated)
+                throw new Error('pull invalidated');
+        }
     }
     getPullLifecycle(namespace) {
         const ns = this.pullScopeKey(namespace);
@@ -901,16 +1049,21 @@ export class RpcPipeline {
             return;
         }
         job.running = true;
-        void this.executePullOperation(job.operation, job.background).then(job.resolve, job.reject).finally(() => {
-            if (job.timedOut)
-                return;
+        void this.executePullOperation(job.operation, job.background).then((value) => { if (!job.timedOut && !job.invalidated)
+            job.resolve(value); }, (error) => { if (!job.timedOut && !job.invalidated)
+            job.reject(error); }).finally(() => {
+            this.pullWorkTokens.delete(job.workToken);
             state.lifecycle.set(job.namespace, 'idle');
             if (state.active === job)
                 state.active = null;
             if (state.byKey.get(job.key) === job)
                 state.byKey.delete(job.key);
             this.drainPullGate(state);
-            this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+            job.settledResolve?.();
+            job.settledResolve = null;
+            if (!job.invalidated)
+                this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+            this.runtime.client._delivery?.onPullWorkSettled?.();
         });
     }
     armQueuedPullTimers(_state) { }
@@ -936,7 +1089,9 @@ export class RpcPipeline {
                 request = client._transport.call(method, payload);
             return this.bindActivePullCancellation(method, payload, request);
         };
-        return await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+        const result = await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+        this.throwIfPullInvalidated();
+        return result;
     }
     async transportCallWithIdentityRecovery(operation, method, params) {
         try {
@@ -946,11 +1101,25 @@ export class RpcPipeline {
             const recover = this.runtime.client._recoverIdentityAdmission;
             if (typeof recover !== 'function' || !await recover.call(this.runtime.client, err, method, params))
                 throw err;
-            return await operation();
+            let lastError = err;
+            for (const delay of IDENTITY_ADMISSION_RETRY_DELAYS_MS) {
+                if (delay > 0)
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                try {
+                    return await operation();
+                }
+                catch (retryError) {
+                    if (!sameIdentityAdmissionRejection(retryError, err))
+                        throw retryError;
+                    lastError = retryError;
+                }
+            }
+            throw lastError;
         }
     }
     async postprocessResult(method, params, result, options = {}) {
         const client = this.runtime.client;
+        this.throwIfPullInvalidated();
         let next = result;
         if ((method === 'group.send' || method === 'group.v2.send') && isJsonObject(next)) {
             next = normalizeGroupMentionMode(next);