@agentunion/fastaun 0.5.32 → 0.5.33

package/dist/client.js

@@ -54,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) {
@@ -523,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) {
@@ -1333,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) {
@@ -1383,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)
@@ -1420,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) {
@@ -1437,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);
     }
@@ -2028,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);
@@ -2040,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, () => {
@@ -2201,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) {