@agentunion/fastaun 0.5.3 → 0.5.6

package/dist/client/rpc-pipeline.js

@@ -1,9 +1,9 @@
 import * as crypto from 'node:crypto';
 import { normalizeSlotId, slotIsolationKey } from '../config.js';
-import { ClientSignatureError, ConnectionError, PermissionError, StateError, ValidationError } from '../errors.js';
-import { normalizeGroupId } from '../group-id.js';
+import { ClientSignatureError, ConnectionError, PermissionError, ValidationError } from '../errors.js';
 import { ConnectionState, isJsonObject, } from '../types.js';
 import { validateAIDFormat, validateGroupIDFormat } from '../validators.js';
+import { normalizeGroupMentionMode, normalizeGroupSettingsResponse } from './mention-mode.js';
 const INTERNAL_ONLY_METHODS = new Set([
     'auth.login1',
     'auth.aid_login1',
@@ -106,7 +106,7 @@ function getCertFingerprint(certPem) {
     const certObj = new crypto.X509Certificate(certPem);
     return cachePut(certFingerprintCache, key, 'sha256:' + certObj.fingerprint256.replace(/:/g, '').toLowerCase());
 }
-/** pull-gate 防并发窗口，与 client.ts PULL_GATE_STALE_MS 保持一致 */
+/** 旧式 tryAcquirePullGate 的防并发窗口。 */
 const PULL_GATE_STALE_MS = 30000;
 const NON_IDEMPOTENT_TIMEOUT_MS = 35_000;
 const NON_IDEMPOTENT_METHODS = new Set([
@@ -143,6 +143,9 @@ const NON_IDEMPOTENT_METHODS = new Set([
 ]);
 export class RpcPipeline {
     runtime;
+    pullGateStates = new Map();
+    inlineRealtimeScopes = new Set();
+    bypassedPullScopes = new Map();
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -164,17 +167,25 @@ export class RpcPipeline {
             const skipSendResultEnvelope = Boolean(p._skip_send_result_envelope);
             delete p._skip_send_result_envelope;
             const pullGateKey = this.pullGateKeyForCall(method, p);
+            const runWithPullResponseScope = async (operation) => {
+                const scope = pullGateKey ? this.pullScopeKey(pullGateKey) : '';
+                const wrapper = client._withPullResponseProcessing;
+                if (!scope || typeof wrapper !== 'function')
+                    return await operation();
+                return await wrapper.call(client, scope, operation);
+            };
             if (pullGateKey && this.isPullResponseProcessing(pullGateKey)) {
                 client._clientLog.debug(`pull skipped while processing pull response: method=${method} key=${pullGateKey}`);
                 return client._emptyPullResultForCall(method);
             }
             if (pullGateKey && !pullGateLocked) {
+                const pullBackground = this.pullGateBackgroundForCall(method, p);
                 const lockedParams = { ...p, _pull_gate_locked: true };
-                if (rpcBackground)
+                if (pullBackground)
                     lockedParams._rpc_background = true;
                 if (skipSendResultEnvelope)
                     lockedParams._skip_send_result_envelope = true;
-                return await this.runPullSerialized(pullGateKey, async () => this.call(method, lockedParams));
+                return await this.runPullSerialized(pullGateKey, async () => this.call(method, lockedParams), pullBackground);
             }
             if (method === 'message.send') {
                 const encrypt = p.encrypt ?? true;
@@ -193,7 +204,8 @@ export class RpcPipeline {
                 const encrypt = p.encrypt ?? true;
                 delete p.encrypt;
                 if (encrypt) {
-                    return await runWithRpcPriority(() => client._sendGroupV2(String(p.group_aid ?? p.group_id ?? ''), p.payload, {
+                    return await runWithRpcPriority(() => client._sendGroupV2(String(p.group_id ?? p.group_aid ?? ''), p.payload, {
+                        groupAid: String(p.group_aid ?? '').trim() || undefined,
                         messageId: String(p.message_id ?? '') || undefined,
                         timestamp: p.timestamp,
                         protectedHeaders: client._protectedHeadersFromParams(p),
@@ -223,15 +235,22 @@ export class RpcPipeline {
             }
             if (method === 'message.pull' || method === 'message.v2.pull') {
                 await client._ensureV2SessionReady('message.pull');
+                if (p.window_mode === 'tail') {
+                    return await runWithPullResponseScope(() => client._v2E2EE.pullV2TailInternal(p));
+                }
                 const skipAutoAck = p._skip_auto_ack === true || p.skip_auto_ack === true;
                 const force = p.force === true;
                 const afterSeq = Number(p.after_seq ?? 0) || 0;
                 const limit = Number(p.limit ?? 50) || 50;
-                const messages = skipAutoAck
-                    ? await runWithRpcPriority(() => client._pullV2(afterSeq, limit, { skipAutoAck: true, gateLocked: true, force }))
-                    : await runWithRpcPriority(() => client._pullV2(afterSeq, limit, { gateLocked: true, force }));
+                const messages = await runWithPullResponseScope(() => (skipAutoAck
+                    ? runWithRpcPriority(() => client._pullV2(afterSeq, limit, { skipAutoAck: true, gateLocked: true, force }))
+                    : runWithRpcPriority(() => client._pullV2(afterSeq, limit, { gateLocked: true, force }))));
                 return { messages };
             }
+            if (method === 'message.history') {
+                await client._ensureV2SessionReady('message.history');
+                return await client._v2E2EE.historyV2Internal(p);
+            }
             if (method === 'message.ack' || method === 'message.v2.ack') {
                 await client._ensureV2SessionReady('message.ack');
                 return await runWithRpcPriority(() => client._ackV2(Number(p.seq ?? p.up_to_seq ?? 0) || undefined));
@@ -241,21 +260,35 @@ export class RpcPipeline {
                     throw new ValidationError('group.pull requires group_id');
                 }
                 await client._ensureV2SessionReady('group.pull');
+                if (p.window_mode === 'tail') {
+                    return await runWithPullResponseScope(() => client._v2E2EE.pullGroupV2TailInternal(p));
+                }
                 const hasExplicitAfterSeq = 'after_seq' in p || 'after_message_seq' in p;
                 const cursorParams = client._explicitGroupCursorParams(p);
                 const ownsCursor = Object.keys(cursorParams).length === 0 || client._groupCursorTargetsCurrentInstance(cursorParams);
                 const pullOpts = { gateLocked: true };
                 if (hasExplicitAfterSeq)
                     pullOpts.explicitAfterSeq = true;
+                if (p.force === true)
+                    pullOpts.force = true;
                 if (Object.keys(cursorParams).length > 0)
                     pullOpts.cursorParams = cursorParams;
                 if (!ownsCursor)
                     pullOpts.ownsCursor = false;
                 if (String(p.group_id ?? '').trim())
                     pullOpts.wireGroupId = String(p.group_id).trim();
-                const messages = await runWithRpcPriority(() => client._pullGroupV2(String(p.group_aid ?? p.group_id), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, pullOpts));
+                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)));
                 return { messages };
             }
+            if (method === 'group.history') {
+                if (!String(p.group_id ?? p.group_aid ?? '').trim()) {
+                    throw new ValidationError('group.history requires group_id');
+                }
+                await client._ensureV2SessionReady('group.history');
+                return await client._v2E2EE.historyGroupV2Internal(p);
+            }
             if (method === 'group.ack_messages' || method === 'group.v2.ack') {
                 if (!String(p.group_id ?? '').trim()) {
                     throw new ValidationError('group.ack_messages requires group_id');
@@ -266,7 +299,7 @@ export class RpcPipeline {
                 if (method === 'group.ack_messages' && !ownsCursor) {
                     return await runWithRpcPriority(() => client._rawGroupAckMessages(p));
                 }
-                return await runWithRpcPriority(() => client._ackGroupV2(String(p.group_aid ?? p.group_id), Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || undefined));
+                return await runWithRpcPriority(() => client._ackGroupV2(String(p.group_id ?? p.group_aid), Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || undefined, String(p.group_aid ?? '').trim() || undefined));
             }
             if (method === 'message.pull') {
                 delete p._skip_auto_ack;
@@ -285,9 +318,10 @@ export class RpcPipeline {
                 : (rpcBackground
                     ? await client._transport.call(method, p, undefined, undefined, true)
                     : await client._transport.call(method, p));
+            const sendResultModeSource = result;
             result = await this.postprocessResult(method, p, result);
             if (!skipSendResultEnvelope) {
-                result = client._delivery.attachSendResultEnvelope(method, p, result, Boolean(p.encrypted));
+                result = client._delivery.attachSendResultEnvelope(method, p, result, Boolean(p.encrypted), sendResultModeSource);
             }
             client._clientLog.debug(`call exit: method=${method} elapsed=${Date.now() - tStart}ms`);
             return result;
@@ -482,25 +516,159 @@ export class RpcPipeline {
     // ── pull-gate ──────────────────────────────────────────────────────────────
     pullGateKeyForCall(method, params) {
         const client = this.runtime.client;
-        if (method === 'message.pull' || method === 'message.v2.pull') {
-            return client._aid ? `p2p:${client._aid}` : '';
-        }
-        if ((method === 'group.pull' || method === 'group.v2.pull') && String(params.group_aid ?? params.group_id ?? '').trim()) {
-            return `group:${String(params.group_aid ?? params.group_id ?? '').trim()}`;
+        if (method === 'message.pull' || method === 'message.v2.pull' || method === 'message.history') {
+            if (!client._aid)
+                return '';
+            let mode;
+            let cursor;
+            if (method === 'message.history') {
+                mode = 'history';
+                cursor = `before=${String(params.before_seq)}`;
+            }
+            else if (params.window_mode === 'tail') {
+                mode = 'tail';
+                cursor = `after=${String(params.after_seq ?? 0)}`;
+            }
+            else {
+                mode = 'forward';
+                cursor = `after=${String(params.after_seq ?? 0)}|force=${String(Boolean(params.force))}`;
+            }
+            return `p2p:${client._aid}|${mode}|${cursor}|limit=${String(params.limit)}`;
+        }
+        if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
+            const groupId = String(params.group_id ?? params.group_aid ?? '').trim();
+            if (!groupId)
+                return '';
+            let mode;
+            let cursor;
+            if (method === 'group.history') {
+                mode = 'history';
+                cursor = `before=${String(params.before_seq)}`;
+            }
+            else if (params.window_mode === 'tail') {
+                mode = 'tail';
+                cursor = `after=${String(params.after_seq ?? params.after_message_seq ?? 0)}`;
+            }
+            else {
+                mode = 'forward';
+                cursor = `after=${String(params.after_seq ?? params.after_message_seq ?? 0)}|force=${String(Boolean(params.force))}`;
+            }
+            return `group:${groupId}|${mode}|${cursor}|limit=${String(params.limit)}`;
         }
-        if (method === 'group.pull_events' && String(params.group_aid ?? params.group_id ?? '').trim()) {
-            return `group_event:${String(params.group_aid ?? params.group_id ?? '').trim()}`;
+        if (method === 'group.pull_events' && String(params.group_id ?? params.group_aid ?? '').trim()) {
+            const groupId = String(params.group_id ?? params.group_aid ?? '').trim();
+            return `group_event:${groupId}|forward|after=${String(params.after_event_seq ?? 0)}|limit=${String(params.limit)}`;
         }
         return '';
     }
+    pullGateBackgroundForCall(method, params) {
+        if (method === 'message.history' || method === 'group.history')
+            return false;
+        if (method === 'message.pull' || method === 'message.v2.pull' || method === 'group.pull' || method === 'group.v2.pull') {
+            return params.window_mode !== 'tail';
+        }
+        return true;
+    }
+    pullGateName(key) {
+        if (key.startsWith('p2p:'))
+            return 'p2p_message';
+        if (key.startsWith('group:'))
+            return 'group_message';
+        if (key.startsWith('group_event:'))
+            return 'group_event';
+        return `other:${key}`;
+    }
+    pullGateState(key) {
+        const name = this.pullGateName(key);
+        let state = this.pullGateStates.get(name);
+        if (!state) {
+            state = { active: null, foreground: [], background: [], byKey: new Map() };
+            this.pullGateStates.set(name, state);
+        }
+        return state;
+    }
+    pullScopeKey(key) {
+        return key.split('|', 1)[0] ?? key;
+    }
+    hasInlineRealtimeGuard(namespace) {
+        const ns = String(namespace ?? '').trim();
+        return Boolean(ns) && this.inlineRealtimeScopes.has(ns);
+    }
+    async executeBypassedPull(key, operation, background) {
+        const scope = this.pullScopeKey(key);
+        this.bypassedPullScopes.set(scope, (this.bypassedPullScopes.get(scope) ?? 0) + 1);
+        try {
+            return await this.executePullOperation(operation, background);
+        }
+        finally {
+            const remaining = (this.bypassedPullScopes.get(scope) ?? 1) - 1;
+            if (remaining <= 0) {
+                this.bypassedPullScopes.delete(scope);
+            }
+            else {
+                this.bypassedPullScopes.set(scope, remaining);
+            }
+        }
+    }
     isPullResponseProcessing(key) {
         if (!key)
             return false;
-        return (this.runtime.client._pullResponseKeys.get(key) ?? 0) > 0;
+        return (this.runtime.client._pullResponseKeys.get(this.pullScopeKey(key)) ?? 0) > 0;
+    }
+    hasPullActivity(namespace) {
+        const ns = String(namespace ?? '').trim();
+        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:')) || this.hasInlineRealtimeGuard(ns))
+            return true;
+        const client = this.runtime.client;
+        if ((client._pullResponseKeys.get(ns) ?? 0) > 0)
+            return true;
+        if (Number(client._pendingP2pPullUpper?.get?.(ns) ?? 0) > 0)
+            return true;
+        if ((this.bypassedPullScopes.get(ns) ?? 0) > 0)
+            return true;
+        for (const key of client._gapFillDone?.keys?.() ?? []) {
+            const marker = String(key ?? '').trim();
+            if (ns.startsWith('p2p:') && marker.startsWith('p2p:'))
+                return true;
+            if (ns.startsWith('group:') && marker.startsWith(`group_msg:${ns.slice('group:'.length)}:`))
+                return true;
+        }
+        for (const [key, gate] of client._pullGates?.entries?.() ?? []) {
+            if (gate?.inflight && this.pullScopeKey(key) === ns)
+                return true;
+        }
+        for (const state of this.pullGateStates.values()) {
+            const jobs = [state.active, ...state.foreground, ...state.background];
+            if (jobs.some((job) => job !== null && this.pullScopeKey(job.key) === ns))
+                return true;
+        }
+        return false;
+    }
+    async tryRunInlineRealtime(namespace, seq, operation) {
+        const ns = String(namespace ?? '').trim();
+        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:'))
+            || !Number.isSafeInteger(seq) || seq <= 0 || typeof operation !== 'function'
+            || this.hasPullActivity(ns)) {
+            return { acquired: false };
+        }
+        this.inlineRealtimeScopes.add(ns);
+        try {
+            return { acquired: true, value: await operation() };
+        }
+        finally {
+            this.inlineRealtimeScopes.delete(ns);
+            const state = this.pullGateStates.get(this.pullGateName(ns));
+            if (state) {
+                this.drainPullGate(state);
+                this.armQueuedPullTimers(state);
+            }
+        }
     }
     tryAcquirePullGate(key) {
         if (!key)
             return 0;
+        if (this.hasInlineRealtimeGuard(this.pullScopeKey(key)))
+            return null;
         const client = this.runtime.client;
         const now = Date.now();
         const gate = client._pullGates.get(key) ?? { inflight: false, startedAt: 0, token: 0 };
@@ -529,27 +697,123 @@ export class RpcPipeline {
             client._schedulePendingP2pPullIfNeeded(key, 'pull-gate-release');
         }
     }
-    async runPullSerialized(key, operation) {
+    async runPullSerialized(key, operation, background = false) {
         if (key && this.isPullResponseProcessing(key)) {
             this.runtime.client._clientLog.debug(`pull skipped while processing pull response: key=${key}`);
             return [];
         }
-        let token = this.tryAcquirePullGate(key);
-        if (token === null) {
-            const deadline = Date.now() + PULL_GATE_STALE_MS + 100;
-            while (token === null && Date.now() <= deadline) {
-                await this.runtime.client._sleep(25);
-                token = this.tryAcquirePullGate(key);
-            }
-            if (token === null) {
-                throw new StateError(`pull already in-flight for ${key}`);
-            }
-        }
-        try {
+        if (!key)
+            return await this.executePullOperation(operation, background);
+        const state = this.pullGateState(key);
+        const timeoutMs = Math.max(0, Number(this.runtime.client._PULL_GATE_QUEUE_TIMEOUT_MS ?? 3_000) || 0);
+        const existing = state.byKey.get(key);
+        if (existing) {
+            this.runtime.client._clientLog.debug(`pull gate coalesced: gate=${this.pullGateName(key)} key=${key} background=${String(background)}`);
+            if (this.hasInlineRealtimeGuard(this.pullScopeKey(key)))
+                return await existing.promise;
+            return await this.waitForCoalesced(existing.promise, timeoutMs, operation, background, key);
+        }
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+        const job = {
+            key,
+            background,
+            enqueuedAt: Date.now(),
+            operation,
+            promise,
+            resolve,
+            reject,
+            timer: null,
+        };
+        const queue = background ? state.background : state.foreground;
+        queue.push(job);
+        state.byKey.set(key, job);
+        this.drainPullGate(state);
+        if (state.active !== job && !this.hasInlineRealtimeGuard(this.pullScopeKey(job.key))) {
+            job.timer = setTimeout(() => this.bypassQueuedPull(state, job), timeoutMs);
+        }
+        return await promise;
+    }
+    async executePullOperation(operation, background) {
+        if (background)
             return await this.runtime.client._withBackgroundRpc(operation);
+        return await operation();
+    }
+    waitForCoalesced(shared, timeoutMs, operation, background, key) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                this.runtime.client._clientLog.warn(`pull gate coalesced wait timeout, bypass: gate=${this.pullGateName(key)} key=${key} timeout=${timeoutMs}ms`);
+                void this.executeBypassedPull(key, operation, background).then(resolve, reject);
+            }, timeoutMs);
+            shared.then((value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(value);
+            }, (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    bypassQueuedPull(state, job) {
+        if (state.active === job)
+            return;
+        if (this.hasInlineRealtimeGuard(this.pullScopeKey(job.key))) {
+            job.timer = null;
+            return;
         }
-        finally {
-            this.releasePullGate(key, token);
+        const queue = job.background ? state.background : state.foreground;
+        const index = queue.indexOf(job);
+        if (index < 0)
+            return;
+        queue.splice(index, 1);
+        if (state.byKey.get(job.key) === job)
+            state.byKey.delete(job.key);
+        job.timer = null;
+        this.runtime.client._clientLog.warn(`pull gate queue timeout, bypass: gate=${this.pullGateName(job.key)} key=${job.key} background=${String(job.background)}`);
+        void this.executeBypassedPull(job.key, job.operation, job.background).then(job.resolve, job.reject);
+    }
+    drainPullGate(state) {
+        if (state.active)
+            return;
+        const takeRunnable = (queue) => {
+            const index = queue.findIndex((candidate) => !this.hasInlineRealtimeGuard(this.pullScopeKey(candidate.key)));
+            return index >= 0 ? queue.splice(index, 1)[0] : undefined;
+        };
+        const job = takeRunnable(state.foreground) ?? takeRunnable(state.background);
+        if (!job)
+            return;
+        state.active = job;
+        if (job.timer) {
+            clearTimeout(job.timer);
+            job.timer = null;
+        }
+        void this.executePullOperation(job.operation, job.background)
+            .then(job.resolve, job.reject)
+            .finally(() => {
+            if (state.active === job)
+                state.active = null;
+            if (state.byKey.get(job.key) === job)
+                state.byKey.delete(job.key);
+            this.drainPullGate(state);
+        });
+    }
+    armQueuedPullTimers(state) {
+        const timeoutMs = Math.max(0, Number(this.runtime.client._PULL_GATE_QUEUE_TIMEOUT_MS ?? 3_000) || 0);
+        for (const job of [...state.foreground, ...state.background]) {
+            if (!job.timer && !this.hasInlineRealtimeGuard(this.pullScopeKey(job.key))) {
+                job.timer = setTimeout(() => this.bypassQueuedPull(state, job), timeoutMs);
+            }
         }
     }
     // ── raw-call ───────────────────────────────────────────────────────────────
@@ -575,6 +839,12 @@ export class RpcPipeline {
     async postprocessResult(method, params, result) {
         const client = this.runtime.client;
         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);
@@ -605,12 +875,12 @@ export class RpcPipeline {
         if (rawMessages.length) {
             client._seqTracker.onPullResult(ns, rawMessages, Number(params.after_seq ?? 0) || 0);
         }
-        const serverAck = Number(result.server_ack_seq ?? 0);
-        if (serverAck > 0) {
+        const retentionFloor = Math.max(0, Number(result.retention_floor_seq ?? 0));
+        if (retentionFloor > 0) {
             const contig = client._seqTracker.getContiguousSeq(ns);
-            if (contig < serverAck) {
-                client._clientLog?.info?.(`message.pull retention-floor advance: ns=${ns} contiguous=${contig} -> server_ack_seq=${serverAck}`);
-                client._seqTracker.forceContiguousSeq(ns, serverAck);
+            if (contig < retentionFloor) {
+                client._clientLog?.info?.(`message.pull retention-floor advance: ns=${ns} contiguous=${contig} -> retention_floor_seq=${retentionFloor}`);
+                client._seqTracker.forceContiguousSeq(ns, retentionFloor);
             }
         }
         if (client._seqTracker.getContiguousSeq(ns) !== contigBefore) {
@@ -620,7 +890,10 @@ export class RpcPipeline {
     }
     postprocessGroupPull(params, result) {
         const client = this.runtime.client;
-        const gid = String(params.group_aid ?? params.group_id ?? '').trim();
+        if (Array.isArray(result.messages)) {
+            result.messages = result.messages.map((message) => normalizeGroupMentionMode(message));
+        }
+        const gid = String(params.group_id ?? params.group_aid ?? '').trim();
         if (!gid || !client._seqTracker) {
             return;
         }
@@ -632,12 +905,15 @@ export class RpcPipeline {
             client._seqTracker.onPullResult(ns, rawMessages, Number(params.after_message_seq ?? params.after_seq ?? 0) || 0);
         }
         const cursor = isJsonObject(result.cursor) ? result.cursor : null;
-        const serverAck = Number(cursor?.current_seq ?? 0);
-        if (serverAck > 0) {
+        const retentionFloor = Math.max(0, Number(result.retention_floor_message_seq ?? result.retention_floor_seq ?? 0), Number(cursor?.retention_floor_seq ?? 0));
+        const isTail = String(result.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+        const visibilityFloor = isTail ? 0 : Math.max(0, Math.max(0, Number(result.earliest_available_message_seq ?? 1) - 1), Number(cursor?.join_seq ?? 0));
+        const effectiveFloor = Math.max(retentionFloor, visibilityFloor);
+        if (effectiveFloor > 0) {
             const contig = client._seqTracker.getContiguousSeq(ns);
-            if (contig < serverAck) {
-                client._clientLog?.info?.(`group.pull retention-floor advance: ns=${ns} contiguous=${contig} -> cursor.current_seq=${serverAck}`);
-                client._seqTracker.forceContiguousSeq(ns, serverAck);
+            if (contig < effectiveFloor) {
+                client._clientLog?.info?.(`group.pull floor advance: ns=${ns} contiguous=${contig} -> effective_floor=${effectiveFloor} retention_floor=${retentionFloor} visibility_floor=${visibilityFloor} mode=${isTail ? 'tail' : 'forward'}`);
+                client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
             }
         }
         if (client._seqTracker.getContiguousSeq(ns) !== contigBefore) {
@@ -674,33 +950,16 @@ export class RpcPipeline {
             return;
         }
         const record = params;
-        const rawEntries = [
-            ['group_aid', record.group_aid],
-            ['groupAid', record.groupAid],
-            ['group_id', record.group_id],
-            ['groupId', record.groupId],
-        ];
-        const found = rawEntries.find(([, value]) => String(value ?? '').trim());
-        if (found) {
-            const [key, raw] = found;
-            const rawGroupId = String(raw).trim();
-            const normalizedGroupId = normalizeGroupId(rawGroupId);
-            if (normalizedGroupId) {
-                if (normalizedGroupId !== rawGroupId) {
-                    this.runtime.client._clientLog?.debug?.(`call group identifier normalized: ${key}=${rawGroupId} -> ${normalizedGroupId} method=${method}`);
-                }
-                const existingGroupId = String(record.group_id ?? record.groupId ?? '').trim();
-                if (key === 'group_id' || key === 'groupId') {
-                    params.group_id = rawGroupId;
-                }
-                else if (existingGroupId) {
-                    params.group_id = existingGroupId;
-                }
-                else {
-                    params.group_id = normalizedGroupId;
-                }
-                params.group_aid = normalizedGroupId;
-            }
+        const rawGroupId = String(record.group_id ?? record.groupId ?? '').trim();
+        const rawGroupAid = String(record.group_aid ?? record.groupAid ?? '').trim();
+        if (rawGroupId) {
+            params.group_id = rawGroupId;
+        }
+        else if (rawGroupAid) {
+            params.group_id = rawGroupAid;
+        }
+        if (rawGroupAid) {
+            params.group_aid = rawGroupAid;
         }
         delete record.groupAid;
         delete record.groupId;