@agentunion/fastaun-browser 0.5.4 → 0.5.6

package/dist/client/rpc-pipeline.js

@@ -1,9 +1,9 @@
 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 { validateAIDFormat, validateGroupIDFormat } from '../validators.js';
 import { p1363ToDer, pemToArrayBuffer, uint8ToBase64 } from '../crypto.js';
 import { ConnectionState, isJsonObject, } from '../types.js';
+import { normalizeGroupMentionMode, normalizeGroupSettingsResponse } from './mention-mode.js';
 const INTERNAL_ONLY_METHODS = new Set([
     'auth.login1',
     'auth.aid_login1',
@@ -22,11 +22,11 @@ const PROTECTED_HEADERS_METHODS = new Set([
 const SIGNED_METHODS = new Set([
     'message.send',
     'message.v2.put_peer_pk', 'message.v2.bootstrap',
-    'message.v2.group_bootstrap', 'message.v2.pull',
+    'message.v2.group_bootstrap', 'message.v2.pull', 'message.history',
     'message.v2.ack',
     'group.send',
     'group.v2.put_group_pk', 'group.v2.bootstrap',
-    'group.v2.send', 'group.v2.pull', 'group.v2.ack',
+    'group.v2.send', 'group.v2.pull', 'group.history', 'group.v2.ack',
     'group.v2.propose_state', 'group.v2.confirm_state',
     'group.v2.get_proposal',
     'group.kick', 'group.add_member',
@@ -167,6 +167,8 @@ function isTransientV2PullFallbackError(error) {
 }
 export class RpcPipeline {
     runtime;
+    pullGateStates = new Map();
+    bypassedRealtimePulls = new Map();
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -217,7 +219,8 @@ export class RpcPipeline {
             if (encrypt) {
                 await client._ensureV2SessionReady('group.send', 'V2 session not initialized; encrypted group.send requires V2 (V1 E2EE removed)');
                 client._clientLog.debug('call route: group.send -> V2 encrypted send');
-                return await client._sendGroupV2(String(p.group_aid ?? p.group_id ?? ''), p.payload ?? {}, {
+                return await 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),
@@ -246,9 +249,11 @@ export class RpcPipeline {
         }
         const pullGateKey = this.pullGateKeyForCall(method, p);
         if (pullGateKey) {
-            return await this.runPullSerialized(pullGateKey, async () => {
-                return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope));
-            });
+            if (this.isPullResponseProcessing(pullGateKey)) {
+                client._clientLog.debug(`pull skipped while processing pull response: method=${method} key=${pullGateKey}`);
+                return this.emptyPullResultForCall(method);
+            }
+            return await this.runPullSerialized(pullGateKey, async () => await this.callImplInner(method, p, skipSendResultEnvelope), this.pullGateBackgroundForCall(method, p));
         }
         return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope));
     }
@@ -258,6 +263,8 @@ export class RpcPipeline {
             try {
                 await client._ensureV2SessionReady('message.pull');
                 client._clientLog.debug(`call route: ${method} -> V2 pull`);
+                if (p.window_mode === 'tail')
+                    return await client._v2E2EE.pullV2TailInternal(p);
                 const messages = await client._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, { force: p.force === true });
                 return { messages };
             }
@@ -268,29 +275,45 @@ export class RpcPipeline {
                 client._clientLog.warn(`message.pull V2 route unavailable, fallback to plain pull: ${exc instanceof Error ? exc.message : String(exc)}`);
             }
         }
+        if (method === 'message.history') {
+            await client._ensureV2SessionReady('message.history');
+            return await client._v2E2EE.historyV2Internal(p);
+        }
         if (method === 'message.v2.ack' || (method === 'message.ack' && hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('message.ack');
             client._clientLog.debug(`call route: ${method} -> V2 ack`);
-            return await client._ackV2(Number(p.seq ?? p.up_to_seq ?? 0) || undefined);
+            return await client._ackV2((p.seq ?? p.up_to_seq));
         }
         if ((method === 'group.v2.pull' || method === 'group.pull') && p.group_id && (method === 'group.v2.pull' || hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('group.pull');
             client._clientLog.debug(`call route: ${method} -> V2 pull`);
+            if (p.window_mode === 'tail')
+                return await 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 = {};
             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 client._pullGroupV2(String(p.group_aid ?? p.group_id), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, Object.keys(pullOpts).length > 0 ? pullOpts : undefined);
+            if (String(p.group_aid ?? '').trim())
+                pullOpts.groupAid = String(p.group_aid).trim();
+            const messages = await client._pullGroupV2(String(p.group_id ?? p.group_aid), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, Object.keys(pullOpts).length > 0 ? pullOpts : undefined);
             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.v2.ack' || method === 'group.ack_messages') && p.group_id && (method === 'group.v2.ack' || hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('group.ack_messages');
             client._clientLog.debug(`call route: ${method} -> V2 ack`);
@@ -299,7 +322,7 @@ export class RpcPipeline {
             if (!ownsCursor) {
                 return await client._rawGroupAckMessages(p);
             }
-            return await client._ackGroupV2(String(p.group_aid ?? p.group_id), Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || undefined);
+            return await client._ackGroupV2((p.group_id ?? p.group_aid), (p.seq ?? p.msg_seq ?? p.up_to_seq), p.group_aid);
         }
         await this.applyClientSignature(method, p);
         const callTimeout = NON_IDEMPOTENT_METHODS.has(method) ? NON_IDEMPOTENT_TIMEOUT : undefined;
@@ -307,9 +330,10 @@ export class RpcPipeline {
         let result = callTimeout
             ? await client._transport.call(method, p, callTimeout, undefined, rpcBackground)
             : await client._transport.call(method, p, undefined, undefined, rpcBackground);
+        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);
         }
         return result;
     }
@@ -501,22 +525,166 @@ export class RpcPipeline {
     // ── Pull Gate（序列化同一 key 的并发 pull）──────────────────
     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') {
-            const gid = String(params.group_aid ?? params.group_id ?? '').trim();
-            return gid ? `group:${gid}` : '';
+        if (method === 'message.pull' || method === 'message.v2.pull' || method === 'message.history') {
+            if (!client._aid)
+                return '';
+            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)}`;
+        }
+        if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
+            const gid = String(params.group_id ?? params.group_aid ?? '').trim();
+            if (!gid)
+                return '';
+            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)}`;
         }
         if (method === 'group.pull_events') {
-            const gid = String(params.group_aid ?? params.group_id ?? '').trim();
-            return gid ? `group_event:${gid}` : '';
+            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)}`
+                : '';
+        }
+        return '';
+    }
+    pullGateBackgroundForCall(method, params) {
+        if (method === 'message.history' || method === 'group.history')
+            return false;
+        if (['message.pull', 'message.v2.pull', 'group.pull', 'group.v2.pull'].includes(method)) {
+            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;
+    }
+    realtimePullNamespace(key) {
+        for (const marker of ['|tail|', '|forward|']) {
+            const index = key.indexOf(marker);
+            if (index > 0)
+                return key.slice(0, index);
         }
         return '';
     }
+    pullScopeKey(key) {
+        const index = key.indexOf('|');
+        return index < 0 ? key : key.slice(0, index);
+    }
+    isPullResponseProcessing(key) {
+        const responseKeys = this.runtime.client._pullResponseKeys;
+        return Boolean(key) && (responseKeys?.get(this.pullScopeKey(key)) ?? 0) > 0;
+    }
+    emptyPullResultForCall(method) {
+        if (method === 'group.pull_events')
+            return { events: [], count: 0 };
+        return { messages: [], count: 0 };
+    }
+    trackBypassedRealtimePull(key, delta) {
+        const ns = this.realtimePullNamespace(key);
+        if (!ns)
+            return;
+        const next = Math.max(0, (this.bypassedRealtimePulls.get(ns) ?? 0) + delta);
+        if (next === 0)
+            this.bypassedRealtimePulls.delete(ns);
+        else
+            this.bypassedRealtimePulls.set(ns, next);
+    }
+    async executeBypassedPull(key, operation, background) {
+        this.trackBypassedRealtimePull(key, 1);
+        try {
+            return await this.executePullOperation(operation, background);
+        }
+        finally {
+            this.trackBypassedRealtimePull(key, -1);
+        }
+    }
+    hasPendingRealtimePull(ns) {
+        const normalized = String(ns ?? '').trim();
+        if (!normalized || (!normalized.startsWith('p2p:') && !normalized.startsWith('group:')))
+            return false;
+        if (this.isPullResponseProcessing(normalized))
+            return true;
+        if ((this.bypassedRealtimePulls.get(normalized) ?? 0) > 0)
+            return true;
+        const state = this.pullGateStates.get(this.pullGateName(normalized));
+        if (!state)
+            return false;
+        const matches = (job) => {
+            if (!job)
+                return false;
+            return this.realtimePullNamespace(job.key) === normalized;
+        };
+        return matches(state.active)
+            || state.foreground.some(matches)
+            || state.background.some(matches);
+    }
+    async tryRunInlineRealtime(ns, seq, operation) {
+        const normalized = String(ns ?? '').trim();
+        if ((!normalized.startsWith('p2p:') && !normalized.startsWith('group:'))
+            || !Number.isSafeInteger(seq) || seq <= 0 || typeof operation !== 'function') {
+            return { acquired: false };
+        }
+        const client = this.runtime.client;
+        if (this.isPullResponseProcessing(normalized)
+            || (this.bypassedRealtimePulls.get(normalized) ?? 0) > 0) {
+            return { acquired: false };
+        }
+        for (const [key, gate] of client._pullGates?.entries?.() ?? []) {
+            if (gate?.inflight && this.pullScopeKey(key) === normalized)
+                return { acquired: false };
+        }
+        const key = `${normalized}|inline|seq=${seq}`;
+        const state = this.pullGateState(key);
+        if (state.active !== null || state.foreground.length > 0 || state.background.length > 0) {
+            return { acquired: false };
+        }
+        const guard = {
+            key,
+            background: false,
+            inline: true,
+            operation,
+            promise: Promise.resolve(undefined),
+            resolve: () => { },
+            reject: () => { },
+            timer: null,
+        };
+        state.active = guard;
+        try {
+            return { acquired: true, value: await operation() };
+        }
+        finally {
+            if (state.active === guard)
+                state.active = null;
+            this.drainPullGate(state);
+            this.armQueuedPullTimers(state);
+        }
+    }
     tryAcquirePullGate(key) {
         if (!key)
             return 0;
+        const serialized = this.pullGateStates.get(this.pullGateName(key));
+        if (serialized?.active?.inline === true)
+            return null;
         const client = this.runtime.client;
         const now = Date.now();
         const gate = client._pullGates.get(key) ?? { inflight: false, startedAt: 0, token: 0 };
@@ -541,23 +709,95 @@ export class RpcPipeline {
         gate.inflight = false;
         gate.startedAt = 0;
     }
-    async runPullSerialized(key, operation) {
-        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._sleep(25);
-                token = this.tryAcquirePullGate(key);
-            }
-            if (token === null) {
-                throw new StateError(`pull already in-flight for ${key}`);
-            }
-        }
-        try {
-            return await 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 [];
         }
-        finally {
-            this.releasePullGate(key, token);
+        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) {
+            if (state.active?.inline === true)
+                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, operation, promise, resolve, reject, timer: null };
+        (background ? state.background : state.foreground).push(job);
+        state.byKey.set(key, job);
+        this.drainPullGate(state);
+        if (state.active !== job && state.active?.inline !== true) {
+            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}`);
+                void this.executeBypassedPull(key, operation, background).then(resolve, reject);
+            }, timeoutMs);
+            shared.then((value) => { if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(value);
+            } }, (error) => { if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(error);
+            } });
+        });
+    }
+    bypassQueuedPull(state, job) {
+        if (state.active === job)
+            return;
+        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}`);
+        void this.executeBypassedPull(job.key, job.operation, job.background).then(job.resolve, job.reject);
+    }
+    drainPullGate(state) {
+        if (state.active)
+            return;
+        const job = state.foreground.shift() ?? state.background.shift();
+        if (!job)
+            return;
+        state.active = job;
+        if (job.timer)
+            clearTimeout(job.timer);
+        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)
+                job.timer = setTimeout(() => this.bypassQueuedPull(state, job), timeoutMs);
         }
     }
     async rawCall(method, params, options) {
@@ -584,6 +824,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') && isJsonObject(next)) {
+            next = normalizeGroupMentionMode(next);
+        }
+        if (method === 'group.get_settings' || method === 'group.set_settings') {
+            next = normalizeGroupSettingsResponse(next);
+        }
         if (method === 'group.thought.get' && isJsonObject(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);
@@ -616,12 +862,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) {
@@ -631,7 +877,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;
         }
@@ -643,12 +892,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) {
@@ -685,33 +937,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;