@agentplat/mesh 0.3.0-beta.2 → 0.3.0-beta.4

package/dist/coordination-allocation.d.ts

@@ -1,6 +1,6 @@
 import type { MeshAllocationBidSelection, MeshAllocationCommand, MeshAllocationDecision, MeshAllocationRuntimeState, MeshAllocationSelectionInput, MeshAllocationTimerDecision, MeshAllocationTimerInput, MeshVerifiedAllocationRequest } from "./coordination-allocation-contracts.js";
 /** Commits a prepared local offer or award; signing and delivery stay outside. */
-export declare function evaluateMeshAllocationCommand(state: MeshAllocationRuntimeState, command: MeshAllocationCommand, verifiedAt: string, receivedAt: number): MeshAllocationDecision;
+export declare function evaluateMeshAllocationCommand(state: MeshAllocationRuntimeState, command: MeshAllocationCommand, verifiedAt: string, receivedAt: number, supportedCriticalExtensions?: readonly string[], eligibleRecipientPeerIds?: readonly string[]): MeshAllocationDecision;
 /** Evaluates a verified direct bid at the local offer owner. */
 export declare function evaluateVerifiedMeshAllocationEnvelope(state: MeshAllocationRuntimeState, request: MeshVerifiedAllocationRequest): MeshAllocationDecision;
 /** Selects a currently valid bid deterministically while the window is open. */

package/dist/coordination-allocation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordination-allocation.d.ts","sourceRoot":"","sources":["../src/coordination-allocation.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAIV,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,EAGtB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,EASxB,6BAA6B,EAE9B,MAAM,wCAAwC,CAAC;AAsChD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,sBAAsB,CAmVxB;AA2gCD,gEAAgE;AAChE,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,6BAA6B,GACrC,sBAAsB,CA6PxB;AA03BD,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,4BAA4B,GAClC,0BAA0B,CA2E5B;AAED,6DAA6D;AAC7D,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,wBAAwB,EAC/B,WAAW,EAAE,MAAM,GAClB,2BAA2B,CAqJ7B"}
+{"version":3,"file":"coordination-allocation.d.ts","sourceRoot":"","sources":["../src/coordination-allocation.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAIV,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,EAGtB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,EASxB,6BAA6B,EAE9B,MAAM,wCAAwC,CAAC;AAsChD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,2BAA2B,GAAE,SAAS,MAAM,EAAO,EACnD,wBAAwB,CAAC,EAAE,SAAS,MAAM,EAAE,GAC3C,sBAAsB,CAkWxB;AAghCD,gEAAgE;AAChE,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,6BAA6B,GACrC,sBAAsB,CA6PxB;AA03BD,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,4BAA4B,GAClC,0BAA0B,CAwF5B;AAED,6DAA6D;AAC7D,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,wBAAwB,EAC/B,WAAW,EAAE,MAAM,GAClB,2BAA2B,CAqJ7B"}

package/dist/coordination-allocation.js

@@ -1,4 +1,4 @@
-import { canonicalizeMeshPayload, compareMeshTimestamps, validateMeshEnvelopeContext, validateSignedMeshEnvelope, } from "@agentplat/mesh-protocol";
+import { DEFAULT_MESH_PROTOCOL_LIMITS, canonicalizeMeshPayload, compareMeshTimestamps, validateMeshEnvelopeContext, validateSignedMeshEnvelope, } from "@agentplat/mesh-protocol";
 import { createMeshAllocationRuntimeState, meshAllocationRetainsMessageId, meshAssignmentFenceKey, restoreMeshAllocationState, } from "./coordination-allocation-state.js";
 import { matchMeshDiscoveryCapabilities } from "./coordination-discovery.js";
 import { evaluateMeshExecutionCommand, evaluateVerifiedMeshExecutionEnvelope, } from "./coordination-execution.js";
@@ -10,8 +10,10 @@ import { sha256Base64Url } from "./sha256.js";
 import { assertMeshLogicalTime, createFrozenRecord, recordEntries, } from "./state.js";
 const utf8Encoder = new TextEncoder();
 /** Commits a prepared local offer or award; signing and delivery stay outside. */
-export function evaluateMeshAllocationCommand(state, command, verifiedAt, receivedAt) {
+export function evaluateMeshAllocationCommand(state, command, verifiedAt, receivedAt, supportedCriticalExtensions = [], eligibleRecipientPeerIds) {
     assertRuntime(state, receivedAt);
+    assertSupportedCriticalExtensions(supportedCriticalExtensions);
+    assertEligibleRecipientPeerIds(eligibleRecipientPeerIds, state.allocation.limits.maximumRecipientsPerOffer, supportedCriticalExtensions.length > 0);
     if (!command ||
         ![
             "allocation.offer",
@@ -81,7 +83,7 @@ export function evaluateMeshAllocationCommand(state, command, verifiedAt, receiv
         .filter((offer) => offer.objectiveId === work.objectiveId &&
         offer.work.workItemId === work.workItemId)
         .sort((a, b) => a.offerAttempt - b.offerAttempt);
-    const prepared = validatePrepared(command.recipients, state, work, verifiedAt, receivedAt, priorOffers.at(-1));
+    const prepared = validatePrepared(command.recipients, state, work, verifiedAt, receivedAt, priorOffers.at(-1), supportedCriticalExtensions, eligibleRecipientPeerIds);
     if ("code" in prepared)
         return reject(state, prepared.code);
     const { payload, entries, bidDeadlineAt } = prepared;
@@ -155,6 +157,13 @@ export function evaluateMeshAllocationCommand(state, command, verifiedAt, receiv
         bidDeadlineTimerGeneration: generation,
         createdAt: receivedAt,
         validityVerifiedAt: verifiedAt,
+        ...(supportedCriticalExtensions.length === 0
+            ? {}
+            : {
+                supportedCriticalExtensions: Object.freeze([
+                    ...supportedCriticalExtensions,
+                ]),
+            }),
         reservationId,
         recipientOffers: createFrozenRecord(entries.map(({ recipientPeerId, preparedAt, envelope }) => [
             recipientPeerId,
@@ -275,8 +284,10 @@ export function evaluateMeshAllocationCommand(state, command, verifiedAt, receiv
     });
 }
 function evaluateAwardCommand(state, command, verifiedAt, receivedAt) {
-    if (Object.keys(command).sort().join(",") !==
-        "bidId,bidRevision,kind,offerId,recipient" ||
+    const commandKeys = Object.keys(command).sort().join(",");
+    if ((commandKeys !== "bidId,bidRevision,kind,offerId,recipient" &&
+        commandKeys !==
+            "bidId,bidRevision,excludedBidderPeerIds,kind,offerId,recipient") ||
         !command.recipient ||
         Object.keys(command.recipient).sort().join(",") !==
             "envelope,preparedAt,recipientPeerId")
@@ -292,6 +303,9 @@ function evaluateAwardCommand(state, command, verifiedAt, receivedAt) {
     const selected = selectMeshAllocationBid(state, {
         offerId: offer.offerId,
         evaluatedAt: receivedAt,
+        ...(command.excludedBidderPeerIds === undefined
+            ? {}
+            : { excludedBidderPeerIds: command.excludedBidderPeerIds }),
     });
     if (selected.reason !== "selected" ||
         !selected.bid ||
@@ -1942,12 +1956,21 @@ function isWitnessCopy(state, request) {
 }
 /** Selects a currently valid bid deterministically while the window is open. */
 export function selectMeshAllocationBid(state, input) {
+    const inputKeys = input && typeof input === "object"
+        ? Object.keys(input).sort().join(",")
+        : "";
+    const excludedBidderPeerIds = input?.excludedBidderPeerIds ?? [];
     if (!input ||
         typeof input !== "object" ||
-        Object.keys(input).sort().join(",") !== "evaluatedAt,offerId" ||
+        (inputKeys !== "evaluatedAt,offerId" &&
+            inputKeys !== "evaluatedAt,excludedBidderPeerIds,offerId") ||
         typeof input.offerId !== "string" ||
         !Number.isSafeInteger(input.evaluatedAt) ||
-        input.evaluatedAt < 0)
+        input.evaluatedAt < 0 ||
+        !Array.isArray(excludedBidderPeerIds) ||
+        excludedBidderPeerIds.length > 256 ||
+        new Set(excludedBidderPeerIds).size !== excludedBidderPeerIds.length ||
+        excludedBidderPeerIds.some((peerId) => typeof peerId !== "string" || peerId.length === 0))
         throw new TypeError("Invalid Mesh allocation selection input");
     assertRuntime(state, input.evaluatedAt);
     const offer = state.allocation.localOffers[input.offerId];
@@ -1976,6 +1999,8 @@ export function selectMeshAllocationBid(state, input) {
     const eligible = Object.values(state.allocation.bidHeads).filter((bid) => {
         if (bid.offerId !== input.offerId)
             return false;
+        if (excludedBidderPeerIds.includes(bid.bidderPeerId))
+            return false;
         const evidence = state.allocation.acceptedBidEvidence[bid.bidId];
         if (!evidence)
             return false;
@@ -2317,7 +2342,7 @@ function evaluateAcceptanceDeadline(state, timer, logicalTime) {
         state: createMeshAllocationRuntimeState(coordination, Object.freeze({ ...state.discovery, lastLogicalTime: logicalTime }), objectives, allocation),
     });
 }
-function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previousOffer) {
+function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previousOffer, supportedCriticalExtensions = [], eligibleRecipientPeerIds) {
     if (!Array.isArray(recipients) ||
         !recipients.length ||
         recipients.length > state.allocation.limits.maximumRecipientsPerOffer)
@@ -2327,6 +2352,13 @@ function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previ
     if (!parsed?.ok || parsed.value.payload.type !== "work.offer")
         return { code: "offer_invalid" };
     const payload = parsed.value.payload;
+    const firstEnvelope = parsed.value;
+    const priorEnvelope = previousOffer
+        ? Object.values(previousOffer.recipientOffers)[0]?.envelope
+        : undefined;
+    if (priorEnvelope !== undefined &&
+        !preservesCriticalSemantics(firstEnvelope, priorEnvelope))
+        return { code: "offer_invalid" };
     const bidDeadlineAt = logicalDeadline(payload.bidDeadline, verifiedAt, receivedAt);
     if (bidDeadlineAt === undefined)
         return { code: "offer_invalid" };
@@ -2335,10 +2367,15 @@ function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previ
         attributes: work.matchingAttributes,
         fanout: Math.min(state.allocation.limits.maximumRecipientsPerOffer, state.discovery.limits.maximumFanout),
     }, receivedAt).matches.map((match) => match.peerId);
+    const constrainedMatches = eligibleRecipientPeerIds === undefined
+        ? matches
+        : matches.filter((peerId) => eligibleRecipientPeerIds.includes(peerId));
     const ids = recipients.map((item) => item.recipientPeerId);
-    if (new Set(ids).size !== ids.length ||
-        ids.length !== matches.length ||
-        ids.some((id, index) => id !== matches[index]))
+    if ((eligibleRecipientPeerIds !== undefined &&
+        eligibleRecipientPeerIds.some((peerId) => !matches.includes(peerId))) ||
+        new Set(ids).size !== ids.length ||
+        ids.length !== constrainedMatches.length ||
+        ids.some((id, index) => id !== constrainedMatches[index]))
         return { code: "offer_invalid" };
     const entries = [];
     const retainedMessageIds = new Set([
@@ -2353,6 +2390,7 @@ function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previ
             meshId: state.allocation.identity.meshId,
             peerId: item.recipientPeerId,
             receivedAt: verifiedAt,
+            supportedCriticalExtensions,
         });
         if (!result.ok ||
             result.value.payload.type !== "work.offer" ||
@@ -2367,6 +2405,7 @@ function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previ
                 : result.value.causationId !==
                     previousOffer?.recipientOffers[item.recipientPeerId]?.messageId) ||
             !samePayload(result.value.payload, payload) ||
+            !sameCriticalSemantics(result.value, firstEnvelope) ||
             !canonicalDigest(result.value))
             return { code: "offer_invalid" };
         if (retainedMessageIds.has(result.value.messageId) ||
@@ -2381,6 +2420,48 @@ function validatePrepared(recipients, state, work, verifiedAt, receivedAt, previ
     }
     return { payload, entries: Object.freeze(entries), bidDeadlineAt };
 }
+function assertSupportedCriticalExtensions(value) {
+    const descriptors = Array.isArray(value)
+        ? Object.getOwnPropertyDescriptors(value)
+        : undefined;
+    if (!Array.isArray(value) ||
+        value.length > DEFAULT_MESH_PROTOCOL_LIMITS.maximumCriticalExtensions ||
+        Reflect.ownKeys(value).length !== value.length + 1 ||
+        Object.values(descriptors ?? {}).some((descriptor) => "get" in descriptor || "set" in descriptor))
+        throw new TypeError("Invalid Mesh supported critical extensions");
+    const seen = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(value, index))
+            throw new TypeError("Invalid Mesh supported critical extensions");
+        const extension = value[index];
+        if (typeof extension !== "string" ||
+            extension.length < 1 ||
+            seen.has(extension))
+            throw new TypeError("Invalid Mesh supported critical extensions");
+        seen.add(extension);
+    }
+}
+function assertEligibleRecipientPeerIds(value, maximumRecipients, criticalExtensionEnabled) {
+    if (value === undefined)
+        return;
+    if (!criticalExtensionEnabled ||
+        !Array.isArray(value) ||
+        value.length < 1 ||
+        value.length > maximumRecipients ||
+        new Set(value).size !== value.length ||
+        value.some((peerId) => typeof peerId !== "string" || peerId.length < 1))
+        throw new TypeError("Invalid Mesh eligible recipient peer IDs");
+}
+function sameCriticalSemantics(left, right) {
+    if (!sameData(left.criticalExtensions ?? [], right.criticalExtensions ?? []))
+        return false;
+    return (left.criticalExtensions ?? []).every((key) => sameData(left.extensions?.[key], right.extensions?.[key]));
+}
+function preservesCriticalSemantics(current, previous) {
+    const currentCritical = new Set(current.criticalExtensions ?? []);
+    return (previous.criticalExtensions ?? []).every((key) => currentCritical.has(key) &&
+        sameData(current.extensions?.[key], previous.extensions?.[key]));
+}
 function validateContext(state, request) {
     if (!request ||
         typeof request !== "object" ||