@agentunion/fastaun 0.5.31 → 0.5.33

package/dist/client.d.ts

@@ -12,14 +12,16 @@
  */
 import { AIDStore } from './aid-store.js';
 import { type Subscription, type EventHandler } from './events.js';
+import { type RpcCallOptions } from './client/rpc-pipeline.js';
 import { type RiskStateEvent } from './risk-control.js';
 import { CollabClient } from './collab/client.js';
 import { DebugFacade, CredentialFacade, OrgFacade, GroupFacade, MailFacade, MessageFacade, StreamFacade } from './facades.js';
+import { EventService } from './pubsub/index.js';
 import { StorageVFS } from './storage/vfs.js';
 import { type JsonObject, type JsonValue, type RpcParams, type RpcResult, ConnectionState } from './types.js';
 import { AID } from './aid.js';
 import { type OwnershipConsensusResult } from './ownership-v21.js';
-import { type OwnershipTaskResult } from './ownership-workflow.js';
+import { type OwnershipRequestOptions, type OwnershipApprovalBatchResult, type OwnershipTaskResult } from './ownership-workflow.js';
 import { type CertificateMaterial } from './org-protocol.js';
 import { type RecordVerificationContext as SemanticRecordVerificationContext, type SemanticMessageVerificationContext } from './semantic-protocol.js';
 import type { SemanticPersistentState } from './semantic-facade.js';
@@ -102,6 +104,7 @@ export declare class AUNClient {
     private _credentialRenewalTimer;
     private _credentialRenewalAbort;
     private _credentialRenewalScan;
+    private _credentialRenewalBackground;
     private _nextCredentialRevocationSyncAt;
     private _getCredentialRenewal;
     _assertCredentialNotRevoked(credential: JsonObject, proofChain?: JsonObject[]): () => void;
@@ -266,6 +269,7 @@ export declare class AUNClient {
     private _storage?;
     private _collab?;
     private _message?;
+    private _eventServiceFacade?;
     private _debug?;
     private _mail?;
     private _group?;
@@ -284,6 +288,7 @@ export declare class AUNClient {
     /** AUN Collab 入口 */
     get collab(): CollabClient;
     get debug(): DebugFacade;
+    get EventService(): EventService;
     /** Message facade 入口 */
     get message(): MessageFacade;
     /** Group facade 入口 */
@@ -298,14 +303,14 @@ export declare class AUNClient {
     get_owner(): string | null;
     getOwnershipStatus(): Record<string, unknown>;
     get_ownership_status(): Record<string, unknown>;
-    bindOwneraid(ownerAid: string): Promise<OwnershipTaskResult>;
-    bindSubaid(subAid: string): Promise<OwnershipTaskResult>;
+    bindOwneraid(ownerAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
+    bindSubaid(subAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
     bindLocalSubaid(subClient: AUNClient): Promise<OwnershipTaskResult>;
     transferLocalSubaid(subClient: AUNClient, newOwnerClient: AUNClient): Promise<OwnershipTaskResult>;
     private _createOwnershipOperationClient;
     private _localOwnershipOperation;
     releaseSubaid(subAid: string): Promise<OwnershipTaskResult>;
-    transferSubaid(subAid: string, newOwnerAid: string): Promise<OwnershipTaskResult>;
+    transferSubaid(subAid: string, newOwnerAid: string, options?: OwnershipRequestOptions): Promise<OwnershipTaskResult>;
     checkOwnershipConsensus(subAid?: string, force?: boolean): Promise<OwnershipConsensusResult>;
     private _checkOwnershipConsensusFresh;
     bindAid(subjectAid: string, options?: {
@@ -326,6 +331,9 @@ export declare class AUNClient {
     bind_owner(ownerAid: string, options?: Parameters<AUNClient['bindOwner']>[1]): Promise<RpcResult>;
     releaseOwnership(subjectAid: string): Promise<RpcResult>;
     release_ownership(subjectAid: string): Promise<RpcResult>;
+    acceptOwnershipRequests(operationIds: string[]): Promise<OwnershipApprovalBatchResult>;
+    rejectOwnershipRequests(operationIds: string[], reason?: string): Promise<OwnershipApprovalBatchResult>;
+    private _approveOwnershipRequests;
     acceptOwnershipRequest(operationId: string): Promise<OwnershipTaskResult>;
     rejectOwnershipRequest(operationId: string, reason?: string): Promise<OwnershipTaskResult>;
     private _handleOwnershipMessage;
@@ -400,7 +408,7 @@ export declare class AUNClient {
      * 发送 JSON-RPC 调用。
      * 自动处理内部方法限制、E2EE 加解密、客户端签名等。
      */
-    call(method: string, params?: RpcParams): Promise<RpcResult>;
+    call(method: string, params?: RpcParams, options?: RpcCallOptions): Promise<RpcResult>;
     private _entityOwnershipGuard;
     private _prepareEntityOwnershipLifecycle;
     private _checkEntityOwnershipOnAccess;

package/dist/client.js

@@ -42,6 +42,7 @@ import { RiskController } from './risk-control.js';
 import { ControlMessageCoordinator, messageClassOf } from './client/control-messages.js';
 import { CollabClient } from './collab/client.js';
 import { DebugFacade, CredentialFacade, OrgFacade, GroupFacade, MailFacade, MessageFacade, StreamFacade } from './facades.js';
+import { EventService } from './pubsub/index.js';
 import { StorageVFS } from './storage/vfs.js';
 import { V2E2EECoordinator } from './client/v2-e2ee.js';
 import { GroupStateCoordinator } from './client/group-state.js';
@@ -53,7 +54,7 @@ import { AID } from './aid.js';
 import { certFingerprint, certMatchesFingerprint, normalizeFingerprintHex, publicKeyMatchesFingerprint } from './cert-utils.js';
 import { validateAgentMdCertificate, validateAgentMdDocument, validateAgentMdReadDocument } from './agent-md-schema.js';
 import { OwnershipFiles, OwnershipStorageAdapter, ownershipAid, ownershipFailure, ownershipSha256, parseOwnershipFile, signOwnershipFile } from './ownership-v21.js';
-import { OwnershipWorkflow, OWNERSHIP_SDK_MESSAGE_TYPE, parseOwnershipMessage } from './ownership-workflow.js';
+import { ownershipApprovalBatch, OwnershipWorkflow, OWNERSHIP_SDK_MESSAGE_TYPE, parseOwnershipMessage } from './ownership-workflow.js';
 import { canonicalJson, createCredential, createMemberCredential, signMembershipBinding, digest, validateMembershipBinding, verifyMembershipBinding, verifyCredentialSignature, createRepresentationProof, verifyServiceEvent, buildRequestBinding, validateRequestBinding, CredentialRenewal } from './org-protocol.js';
 import { SemanticProtocolError } from './semantic-protocol.js';
 function isPromiseLike(value) {
@@ -522,7 +523,16 @@ export class AUNClient {
             currentType: () => this.getType(), assertCurrent: () => this._ownershipOperationGuard?.(),
             recoverRequest: (operationId) => this._recoverOwnershipRequest(operationId),
             send: (to, payload, messageId) => this.call('message.send', { to, encrypt: true, message_id: messageId, payload: payload }),
-            emit: (event, payload) => { this._ownershipConsensusCache = new Map(); this._dispatcher.enqueue(event, payload); },
+            emit: (event, payload) => {
+                this._ownershipConsensusCache = new Map();
+                if (typeof payload.sub_aid === 'string') {
+                    try {
+                        this._agentMdManager.updateRecord(payload.sub_aid, (record) => { delete record.ownership_snapshot; });
+                    }
+                    catch { }
+                }
+                this._dispatcher.enqueue(event, payload);
+            },
         });
     }
     async _recoverOwnershipRequest(operationId) {
@@ -591,6 +601,7 @@ export class AUNClient {
     _credentialRenewalTimer = null;
     _credentialRenewalAbort = null;
     _credentialRenewalScan = Promise.resolve();
+    _credentialRenewalBackground = false;
     _nextCredentialRevocationSyncAt = 0;
     _getCredentialRenewal() {
         return this._credentialRenewal ??= new CredentialRenewal({
@@ -625,6 +636,8 @@ export class AUNClient {
             certificate: (aid, fingerprint, signedAt) => signedAt === undefined
                 ? this._fetchServiceEventCertificate(aid, fingerprint) : this._fetchPeerCert(aid, fingerprint, undefined, signedAt),
             call: (method, params, onSent) => {
+                if (this._credentialRenewalBackground && params._rpc_background === undefined && params._rpc_background_kind === undefined)
+                    params = { ...params, _rpc_background: true };
                 if (!onSent)
                     return this._rpcPipeline.call(method, params);
                 const version = this._serviceEventIdentityVersion, aid = this._aid;
@@ -634,7 +647,7 @@ export class AUNClient {
                     await onSent();
                 });
             },
-            send: (to, payload) => this.call('message.send', { to, encrypt: true, payload }),
+            send: (to, payload) => this.call('message.send', { to, encrypt: true, payload, ...(this._credentialRenewalBackground ? { _rpc_background: true } : {}) }),
         });
     }
     _assertCredentialNotRevoked(credential, proofChain) {
@@ -710,10 +723,18 @@ export class AUNClient {
             const task = this._credentialRenewalScan.then(async () => {
                 if (!current())
                     return;
+                if (this._transport._rateLimitRemainingMs() > 0)
+                    return;
                 const syncRevocations = this._sessionOptions.connection_kind !== 'short' && Date.now() >= this._nextCredentialRevocationSyncAt;
                 if (syncRevocations)
                     this._nextCredentialRevocationSyncAt = Date.now() + 3_600_000;
-                await this._resumeCredentialRenewalAfterConnect(guard, syncRevocations);
+                this._credentialRenewalBackground = true;
+                try {
+                    await this._resumeCredentialRenewalAfterConnect(guard, syncRevocations);
+                }
+                finally {
+                    this._credentialRenewalBackground = false;
+                }
             });
             this._credentialRenewalScan = task.catch(() => { });
             await this._safeAsync(task);
@@ -1035,6 +1056,7 @@ export class AUNClient {
     _storage;
     _collab;
     _message;
+    _eventServiceFacade;
     _debug;
     _mail;
     _group;
@@ -1275,6 +1297,11 @@ export class AUNClient {
             });
         return this._debug;
     }
+    get EventService() {
+        if (!this._eventServiceFacade)
+            this._eventServiceFacade = new EventService(this);
+        return this._eventServiceFacade;
+    }
     /** Message facade 入口 */
     get message() {
         if (!this._message)
@@ -1315,8 +1342,8 @@ export class AUNClient {
     get_ownership_status() {
         return this.getOwnershipStatus();
     }
-    async bindOwneraid(ownerAid) { return this._getOwnershipWorkflow().bindOwneraid(ownerAid); }
-    async bindSubaid(subAid) { return this._getOwnershipWorkflow().bindSubaid(subAid); }
+    async bindOwneraid(ownerAid, options) { return this._getOwnershipWorkflow().bindOwneraid(ownerAid, options); }
+    async bindSubaid(subAid, options) { return this._getOwnershipWorkflow().bindSubaid(subAid, options); }
     async bindLocalSubaid(subClient) { return this._localOwnershipOperation(subClient); }
     async transferLocalSubaid(subClient, newOwnerClient) { return this._localOwnershipOperation(subClient, newOwnerClient); }
     _createOwnershipOperationClient(slotId) {
@@ -1330,8 +1357,8 @@ export class AUNClient {
     }
     async _localOwnershipOperation(sub, next) {
         const sources = [this, sub, ...(next ? [next] : [])];
-        if (sources.some((source, index) => !(source instanceof AUNClient) || !source._currentAid?.isPrivateKeyValid() || !source._currentAid.isCertValid() || !source._currentAid.privateKeyPem || source._currentAid.aid !== source._aid || (index === 1 ? source.getType() !== 'agent' : !['human', 'agent'].includes(source.getType()))) || new Set(sources.map((source) => source._aid)).size !== sources.length)
-            throw ownershipFailure('forbidden', 'local ownership requires a distinct agent subaid and human or agent owners with private identities');
+        if (sources.some((source, index) => !(source instanceof AUNClient) || !source._currentAid?.isPrivateKeyValid() || !source._currentAid.isCertValid() || !source._currentAid.privateKeyPem || source._currentAid.aid !== source._aid || (index === 1 ? ['human', 'group', 'org'].includes(source.getType()) : !['human', 'agent'].includes(source.getType()))) || new Set(sources.map((source) => source._aid)).size !== sources.length)
+            throw ownershipFailure('forbidden', 'local ownership requires a distinct non-human subaid outside group/org lifecycles and human or agent owners with private identities');
         const identities = sources.map((source) => [source._aid, source._currentAid, source._serviceEventIdentityVersion]);
         const guard = () => { if (sources.some((source, index) => source._aid !== identities[index][0] || source._currentAid !== identities[index][1] || source._serviceEventIdentityVersion !== identities[index][2]))
             throw ownershipFailure('conflict', 'local ownership source identity changed'); };
@@ -1343,8 +1370,8 @@ export class AUNClient {
                 throw ownershipFailure('forbidden', 'local ownership requires a published agent document');
             const verified = await source._getOwnershipFiles().verifyFile(document.content, 'agent', source._aid);
             guard();
-            if ((index === 1 ? verified.frontmatter.type !== 'agent' : typeof verified.frontmatter.type !== 'string' || !['human', 'agent'].includes(verified.frontmatter.type)))
-                throw ownershipFailure('forbidden', 'local ownership requires an agent subaid and human or agent owners');
+            if (typeof verified.frontmatter.type !== 'string' || !verified.frontmatter.type.trim() || (index === 1 ? ['human', 'group', 'org'].includes(verified.frontmatter.type) : !['human', 'agent'].includes(verified.frontmatter.type)))
+                throw ownershipFailure('forbidden', 'local ownership requires a non-human subaid outside group/org lifecycles and human or agent owners');
         }
         const slot = `ownership-${crypto.randomUUID()}`, clients = [];
         try {
@@ -1365,24 +1392,34 @@ export class AUNClient {
         }
     }
     async releaseSubaid(subAid) { return this._getOwnershipWorkflow().releaseSubaid(subAid); }
-    async transferSubaid(subAid, newOwnerAid) { return this._getOwnershipWorkflow().transferSubaid(subAid, newOwnerAid); }
+    async transferSubaid(subAid, newOwnerAid, options) { return this._getOwnershipWorkflow().transferSubaid(subAid, newOwnerAid, options); }
     async checkOwnershipConsensus(subAid, force = false) {
         const target = ownershipAid(subAid ?? this._aid, 'sub_aid');
-        const record = this._agentMdManager.loadRecord(target);
+        const manager = this._agentMdManager;
+        const record = manager.loadRecord(target);
         const observedEtag = String(record?.remote_etag ?? '');
+        const observation = { root: manager.root, etag: observedEtag, version: Number(record?.observation_version ?? 0), content_hash: typeof record?.content === 'string' ? ownershipSha256(record.content) : '' };
         const cache = this._ownershipConsensusCache ??= new Map();
         const cached = cache.get(target);
         if (!force && cached?.result.status === 'consensus' && record?.remote_status !== 'missing'
-            && (observedEtag === cached.observedEtag || observedEtag === cached.result.agent_md_etag)) {
+            && (observedEtag === cached.observedEtag || observedEtag === cached.result.agent_md_etag)
+            && (typeof record?.content !== 'string' || ownershipSha256(record.content) === cached.result.agent_md_sha256)) {
             cached.observedEtag = observedEtag;
             return { ...cached.result };
         }
+        if (!force && !cached) {
+            const local = manager.localOwnershipConsensus(target, record);
+            if (local) {
+                cache.set(target, { observedEtag, result: local });
+                return { ...local };
+            }
+        }
         cache.delete(target);
         const result = { status: 'unavailable', sub_aid: target, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '' };
         const entry = { observedEtag, result: { ...result } };
         cache.set(target, entry);
         try {
-            const snapshot = await this._agentMdManager.readOwnershipFresh(target);
+            const snapshot = await manager.readOwnershipFresh(target);
             Object.assign(result, { relation_version: snapshot.relation_version, lock: snapshot.lock, agent_md_etag: snapshot.etag,
                 agent_md_sha256: snapshot.exists ? ownershipSha256(snapshot.content) : '' });
             if (snapshot.ownership_status)
@@ -1402,8 +1439,13 @@ export class AUNClient {
             result.reason = error instanceof Error ? error.message : String(error);
             result.retryable = result.status === 'unavailable';
         }
-        if (cache.get(target) === entry)
+        if (this._agentMdManager === manager && this._ownershipConsensusCache === cache && cache.get(target) === entry) {
             entry.result = { ...result };
+            try {
+                manager.cacheOwnershipSnapshot(target, result, observation);
+            }
+            catch { }
+        }
         return result;
     }
     async _checkOwnershipConsensusFresh(subAid) {
@@ -1419,6 +1461,20 @@ export class AUNClient {
     async bind_owner(ownerAid, options = {}) { return this.bindOwner(ownerAid, options); }
     async releaseOwnership(subjectAid) { throw ownershipFailure('unsupported_protocol', 'legacy releaseOwnership is unsupported; use releaseSubaid'); }
     async release_ownership(subjectAid) { return this.releaseOwnership(subjectAid); }
+    async acceptOwnershipRequests(operationIds) {
+        return this._approveOwnershipRequests(operationIds);
+    }
+    async rejectOwnershipRequests(operationIds, reason) {
+        return this._approveOwnershipRequests(operationIds, true, reason);
+    }
+    async _approveOwnershipRequests(operationIds, reject = false, reason) {
+        const aid = this._aid, generation = this._serviceEventIdentityVersion;
+        return ownershipApprovalBatch(operationIds, async (operationId) => {
+            if (this._aid !== aid || this._serviceEventIdentityVersion !== generation)
+                throw new StateError('ownership approval identity changed', { stringCode: 'conflict' });
+            return reject ? this.rejectOwnershipRequest(operationId, reason) : this.acceptOwnershipRequest(operationId);
+        });
+    }
     async acceptOwnershipRequest(operationId) {
         return this._getOwnershipWorkflow().acceptOwnershipRequest(operationId);
     }
@@ -1904,14 +1960,14 @@ export class AUNClient {
      * 发送 JSON-RPC 调用。
      * 自动处理内部方法限制、E2EE 加解密、客户端签名等。
      */
-    async call(method, params) {
+    async call(method, params, options) {
         const assertCurrent = ['group.transfer_owner', 'org.lifecycle.transfer', 'group.dissolve', 'org.lifecycle.dissolve'].includes(method) ? this._entityOwnershipGuard() : undefined;
         const recoverOwnership = ['group.transfer_owner', 'org.lifecycle.transfer', 'group.dissolve', 'org.lifecycle.dissolve'].includes(method) ? await this._prepareEntityOwnershipLifecycle(method, params ?? {}) : undefined;
         await this._checkEntityOwnershipOnAccess(method, params ?? {});
         const readIdentity = ['message.read', 'message.read_state', 'group.read', 'group.read_state'].includes(method)
             ? this._ensureReadStateIdentity() : null;
         try {
-            const result = await this._rpcPipeline.call(method, params, assertCurrent);
+            const result = await (options === undefined ? this._rpcPipeline.call(method, params, assertCurrent) : this._rpcPipeline.call(method, params, assertCurrent, options));
             await this._safeAsync(this._getCredentialRenewal().observe(method, params ?? {}, result));
             if (readIdentity !== null && readIdentity === this._ensureReadStateIdentity())
                 this._observeReadStateResult(method, result, params ?? {});
@@ -2010,6 +2066,9 @@ export class AUNClient {
                     if (!pending?.private_key_pem || !pending.public_key_der_b64)
                         return false;
                 }
+                const local = this._agentMdManager.localOwnershipConsensus(target, this._agentMdManager.loadRecord(target));
+                if (local?.owner_aid === this._aid)
+                    return true;
                 const result = await this._entityLifecycle(target, type);
                 const data = result;
                 const entity = (isJsonObject(data.group) ? data.group : isJsonObject(data.organization) ? data.organization : data);
@@ -2022,7 +2081,7 @@ export class AUNClient {
                         return await existing;
                     this._entityOwnershipChecks.set(`${identity}:${aid}`, task);
                 }
-                const consensus = await this.checkOwnershipConsensus(aid, true);
+                const consensus = await this.checkOwnershipConsensus(aid);
                 if (consensus.status === 'consensus' && consensus.owner_aid === this._aid)
                     return true;
                 await this._completeEntityOwnership(aid, type, undefined, () => {
@@ -2183,12 +2242,19 @@ export class AUNClient {
         if (!aid)
             return;
         try {
-            const checked = await this._agentMdManager.check(aid, 0);
-            if (!checked.remote_found) {
-                await this._ensureInitialAgentMd();
-            }
-            else if (checked.in_sync === false) {
-                await this._agentMdManager.download(aid);
+            const record = this._agentMdManager.loadRecord(aid);
+            const verified = record?.verified_agent_md;
+            const local = record?.content && record.remote_status !== 'missing' && record.remote_etag
+                && (record.local_etag === record.remote_etag || record.verify_status === 'verified' && verified?.etag === record.remote_etag && verified.content_hash === record.local_etag
+                    || this._agentMdManager.localOwnershipConsensus(aid, record));
+            if (!local) {
+                const checked = await this._agentMdManager.check(aid, 0);
+                if (!checked.remote_found) {
+                    await this._ensureInitialAgentMd();
+                }
+                else if (checked.in_sync === false) {
+                    await this._agentMdManager.download(aid);
+                }
             }
         }
         catch (exc) {
@@ -3231,8 +3297,8 @@ export class AUNClient {
         const messageEvent = event === 'message.received' || event === 'message.recalled' || event === 'message.batch';
         const hadMessageConsumer = messageEvent && [...this._dispatcher._snapshotApplicationHandlers(['message.received', 'message.recalled', 'message.batch']).values()].some((handlers) => handlers.length > 0);
         const result = this._dispatcher.subscribe(event, handler);
-        if (messageEvent) {
-            if (this._p2pPeerPullEnabled && !hadMessageConsumer)
+        if (messageEvent || event === 'group.message_created' || event === 'group.message_batch') {
+            if (messageEvent && this._p2pPeerPullEnabled && !hadMessageConsumer)
                 this._delivery.refreshPendingPeers();
             this._delivery.requestBackgroundPullRecovery();
         }
@@ -3376,7 +3442,7 @@ export class AUNClient {
         const errors = [];
         for (const entry of [...this._readStateQueries.values()]) {
             try {
-                const result = await this.call(entry.method, { ...entry.params });
+                const result = await this.call(entry.method, { ...entry.params, _rpc_background: true });
                 if (identity !== this._ensureReadStateIdentity())
                     return;
                 this._observeReadStateResult(entry.method, result, entry.params);
@@ -4386,7 +4452,7 @@ export class AUNClient {
         const seen = new Set();
         do {
             if (response === undefined) {
-                response = await this.call('group.list_my_invites', cursor ? { cursor } : {});
+                response = await this.call('group.list_my_invites', { ...(cursor ? { cursor } : {}), _rpc_background: true });
             }
             let items = [];
             let nextCursor = '';
@@ -4500,6 +4566,7 @@ export class AUNClient {
         const tStart = Date.now();
         connectionOwner ??= this._connectAbort ?? undefined;
         this._lifecycle.assertConnectionAttemptOwner(connectionOwner);
+        this._controlMessageCoordinator?.close();
         const gatewayUrl = this._resolveGateway(params);
         this._gatewayUrl = gatewayUrl;
         this._slotId = String(params.slot_id ?? '');
@@ -4512,7 +4579,7 @@ export class AUNClient {
         delete capabilities.message_classes_v1;
         if (typeof this._tokenStore.updateInstanceState === 'function') {
             capabilities.message_classes_v2 = { p2p: ['normal', 'control', 'sdk_control'], group: ['normal', 'control'] };
-            capabilities.sdk_control_protocols = { 'aun.agent_md.changed': [1] };
+            capabilities.sdk_control_protocols = { 'aun.agent_md.changed': [1], 'aun.pubsub': [1] };
         }
         else {
             delete capabilities.message_classes_v2;
@@ -4657,8 +4724,6 @@ export class AUNClient {
             else {
                 this._clientLog.debug('V2 session init deferred for short connection');
             }
-            this._controlMessages().close();
-            this._safeAsync(this._controlMessages().recover());
             this._agentMdChanges?.close();
             this._agentMdChanges = new AgentMdChangeCoordinator(this);
             // connect/reconnect 成功后自动触发一次 P2P message.v2.pull，补齐离线期间积压
@@ -4672,6 +4737,10 @@ export class AUNClient {
             this._entityOwnershipChecks.clear();
             if (!this._ownershipOperation)
                 this._safeAsync(this._checkIdentityAdmissionAfterConnect());
+            this._safeAsync(this._delivery.restoreMessageClassPulls());
+            if (!isShortConnection && backgroundSyncEnabled && this._v2Session) {
+                this._safeAsync(this._v2AutoConfirmPendingProposals());
+            }
             this._clientLog.debug(`_connectOnce exit: elapsed=${Date.now() - tStart}ms gateway=${gatewayUrl}, aid=${this._aid ?? ''}`);
         }
         catch (err) {
@@ -4823,8 +4892,8 @@ export class AUNClient {
     async _getV2SenderPubDer(fromAid, senderDeviceId, certFingerprint) {
         return await this._v2E2EE.getV2SenderPubDer(fromAid, senderDeviceId, certFingerprint);
     }
-    async _fetchV2SenderIKOnce(fromAid, senderDeviceId, groupId, certFingerprint) {
-        return await this._v2E2EE.fetchSenderIKOnce(fromAid, senderDeviceId, groupId, certFingerprint);
+    async _fetchV2SenderIKOnce(fromAid, senderDeviceId, groupId, certFingerprint, rpcOptions) {
+        return await this._v2E2EE.fetchSenderIKOnce(fromAid, senderDeviceId, groupId, certFingerprint, ...(rpcOptions ? [rpcOptions] : []));
     }
     _cacheV2PeerIKFromDevice(dev, fallbackAid = '') {
         const session = this._v2Session;
@@ -4885,7 +4954,9 @@ export class AUNClient {
         return await this._v2E2EE.ackGroupV2(groupId, upToSeq, groupAid);
     }
     /** 解密单条 V2 pull 消息。缺 sender IK 时先入 pending，后台补齐后重试。 */
-    async _decryptV2Message(msg, allowPending = true, emitUndecryptable = true, rotateKeys = true, observeAgentMd = true, deferStatus, deferKeyFetch = false, source = 'pull', deferredEffects) {
+    async _decryptV2Message(msg, allowPending = true, emitUndecryptable = true, rotateKeys = true, observeAgentMd = true, deferStatus, deferKeyFetch = false, source = 'pull', deferredEffects, rpcOptions) {
+        if (rpcOptions?.deadline !== undefined && rpcOptions.deadline <= Date.now())
+            return null;
         const session = this._v2Session;
         if (!session)
             return null;
@@ -5000,9 +5071,11 @@ export class AUNClient {
         const senderDeviceId = String(aad.from_device ?? '');
         const senderCertFingerprint = String(envelope.sender_cert_fingerprint ?? '').trim().toLowerCase();
         let senderPubDer = await this._getV2SenderPubDer(fromAid, senderDeviceId, senderCertFingerprint);
+        if (rpcOptions?.deadline !== undefined && rpcOptions.deadline <= Date.now())
+            return null;
         if (!senderPubDer && !deferKeyFetch) {
             this._clientLog.warn(`V2 decrypt: no sender IK for ${fromAid} device=${senderDeviceId}`);
-            senderPubDer = await this._fetchV2SenderIKOnce(fromAid, senderDeviceId, groupIdForKeys, senderCertFingerprint);
+            senderPubDer = await this._fetchV2SenderIKOnce(fromAid, senderDeviceId, groupIdForKeys, senderCertFingerprint, ...(rpcOptions ? [rpcOptions] : []));
         }
         if (!senderPubDer) {
             if (allowPending || deferStatus) {
@@ -5334,7 +5407,7 @@ export class AUNClient {
         }
     }
     /** 发现并缓存全部 Gateway 候选，供首连和自动重连故障转移使用。 */
-    async _resolveGatewayCandidatesForAid(aid, fresh = false, reconnectOwner) {
+    async _resolveGatewayCandidatesForAid(aid, fresh = false, reconnectOwner, connectionOwner) {
         const resolvedAid = String(aid ?? this._aid ?? '').trim();
         if (!resolvedAid) {
             throw new StateError('gateway discovery requires a loaded AID');
@@ -5348,7 +5421,8 @@ export class AUNClient {
         const discoveryIsCurrent = () => (this._discovery === discovery
             && this._tokenStore === tokenStore
             && !this._closing
-            && (!reconnectOwner || this._ownsReconnect(reconnectOwner)));
+            && (!reconnectOwner || this._ownsReconnect(reconnectOwner))
+            && (!connectionOwner || this._lifecycle.ownsConnectionAttempt(connectionOwner)));
         if (!fresh && sameIssuer && this._gatewayCandidates.length > 0)
             return [...this._gatewayCandidates];
         if (!fresh && sameIssuer && this._gatewayUrl) {
@@ -5641,6 +5715,11 @@ export class AUNClient {
                     scheduleNext();
                     return;
                 }
+                const rateLimitRemaining = this._transport._rateLimitRemainingMs();
+                if (rateLimitRemaining > 0) {
+                    scheduleNext(rateLimitRemaining);
+                    return;
+                }
                 let identity = this._identity;
                 if (identity === null) {
                     scheduleNext();
@@ -5678,6 +5757,11 @@ export class AUNClient {
                     this._tokenRefreshFailures = 0;
                 }
                 catch (exc) {
+                    if (exc instanceof AUNError && (exc.code === -32429 || exc.code === -32029 || exc.code === 429 || exc.code === 4290)) {
+                        this._transport._observeRateLimit(exc);
+                        scheduleNext(this._transport._rateLimitRemainingMs());
+                        return;
+                    }
                     if (exc instanceof AuthError) {
                         if (authErrorRequiresRelogin(exc)) {
                             this._clientLog.warn(`token refresh requires relogin, stopping refresh loop and triggering reconnect: ${exc.message}`);