agents-can-communicate 0.1.18 → 0.2.0

package/node_modules/@agents-can-communicate/core/src/delivery-bindings.mjs

@@ -0,0 +1,81 @@
+import { AccError, EXIT, SCHEMA_VERSION, validateRecord }
+  from "@agents-can-communicate/protocol";
+
+function conflict(sessionId) {
+  return new AccError(EXIT.CONFLICT,
+    "cannot publish a delivery binding for anything but this open session generation",
+    { sessionId });
+}
+
+export function createDeliveryBindingService(ports, sessions) {
+  const { store } = ports;
+
+  async function currentBindings(now) {
+    const bindings = await store.ephemeral.list("deliveryBinding");
+    const current = [];
+    for (const binding of bindings) {
+      const located = await sessions.locateSession(binding.sessionId);
+      if (located?.record.state !== "open"
+        || located.record.generation !== binding.generation) continue;
+      current.push({ binding, participantId: located.record.participantId,
+        reachable: Date.parse(binding.leaseUntil) > Date.parse(now) });
+    }
+    return current.sort((left, right) =>
+      left.binding.sessionId.localeCompare(right.binding.sessionId));
+  }
+
+  async function publishDeliveryBinding(input) {
+    const located = await sessions.locateSession(input.sessionId);
+    if (located?.record.state !== "open" || located.record.generation !== input.generation) {
+      throw conflict(input.sessionId);
+    }
+    let binding;
+    try {
+      binding = validateRecord("deliveryBinding", {
+        schemaVersion: SCHEMA_VERSION,
+        sessionId: input.sessionId,
+        generation: input.generation,
+        adapterId: input.adapterId,
+        clientVersion: input.clientVersion,
+        availableModes: Array.isArray(input.availableModes)
+          ? [...input.availableModes] : input.availableModes,
+        livePolicy: input.livePolicy,
+        opaqueEndpointRef: input.opaqueEndpointRef,
+        leaseUntil: input.leaseUntil,
+      });
+    } catch (error) {
+      if (error?.details?.field === "opaqueEndpointRef") {
+        throw new AccError(error.code, error.message, { field: "opaqueEndpointRef" });
+      }
+      throw error;
+    }
+    await store.ephemeral.update("deliveryBinding", binding.sessionId, async () => {
+      // This check runs while the ephemeral key's writer lock is held. A stale
+      // publisher that passed the earlier check cannot replace a successor's
+      // endpoint after that successor becomes current.
+      const current = await sessions.locateSession(input.sessionId);
+      if (current?.record.state !== "open"
+        || current.record.generation !== input.generation) {
+        throw conflict(input.sessionId);
+      }
+      return binding;
+    });
+    const stillCurrent = await sessions.locateSession(input.sessionId);
+    if (stillCurrent?.record.state !== "open"
+      || stillCurrent.record.generation !== input.generation) {
+      // Do not delete here: a successor generation may have published between
+      // our put and this recheck. A stale record is filtered on every read and
+      // is safe; deleting a successor's endpoint is not.
+      throw conflict(input.sessionId);
+    }
+    return binding;
+  }
+
+  async function listDeliveryBindings({ participantId, now }) {
+    return (await currentBindings(now))
+      .filter(item => item.participantId === participantId && item.reachable)
+      .map(item => item.binding);
+  }
+
+  return { publishDeliveryBinding, listDeliveryBindings, currentBindings };
+}

package/node_modules/@agents-can-communicate/core/src/finish-retries.mjs

@@ -0,0 +1,97 @@
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+const PAGE_SIZE = 256;
+
+export const projectReleasedClaim = claim => ({
+  claimId: claim.claimId,
+  resource: claim.resource,
+  mode: claim.mode,
+});
+
+function conflict(message) {
+  return new AccError(EXIT.CONFLICT,
+    "clientMessageId belongs to a different finish generation",
+    { clientMessageId: message.clientMessageId, messageId: message.messageId });
+}
+
+async function allEvents(store, workspaceId) {
+  const events = [];
+  let cursor = null;
+  while (true) {
+    const page = await store.eventsSince(workspaceId, cursor, PAGE_SIZE);
+    if (page.events.length === 0) return events;
+    events.push(...page.events);
+    cursor = page.cursor;
+  }
+}
+
+function claimProjection(events, releaseIndex) {
+  const release = events[releaseIndex];
+  const claimId = release.payload.claimId;
+  const facts = events.slice(0, releaseIndex + 1).findLast(event =>
+    (event.type === "claim.acquired" || event.type === "claim.renewed")
+      && event.payload.claimId === claimId
+      && typeof event.payload.resource === "string");
+  return facts === undefined ? null : {
+    claimId,
+    resource: facts.payload.resource,
+    mode: facts.payload.mode,
+  };
+}
+
+function correlatedReleaseIndexes(events, recordedIndex, closedIndex, session, message) {
+  const close = events[closedIndex];
+  const payload = close.payload;
+  const keys = Object.keys(payload).sort();
+  const expectedKeys = ["cause", "messageId", "releasedClaimIds", "sessionGeneration"];
+  if (keys.length !== expectedKeys.length
+    || !keys.every((key, index) => key === expectedKeys[index])
+    || payload.cause !== "finish"
+    || payload.messageId !== message.messageId
+    || payload.sessionGeneration !== session.generation
+    || !Array.isArray(payload.releasedClaimIds)
+    || payload.releasedClaimIds.some(claimId => typeof claimId !== "string")
+    || new Set(payload.releasedClaimIds).size !== payload.releasedClaimIds.length) {
+    throw conflict(message);
+  }
+
+  const between = events.slice(recordedIndex + 1, closedIndex);
+  if (between.length !== payload.releasedClaimIds.length
+    || between.some(event => event.type !== "claim.released"
+      || event.actorSessionId !== session.sessionId
+      || event.payload.authority !== null
+      || event.payload.reason !== null)) {
+    throw conflict(message);
+  }
+  const actualIds = between.map(event => event.payload.claimId);
+  if (actualIds.some((claimId, index) => claimId !== payload.releasedClaimIds[index])) {
+    throw conflict(message);
+  }
+  return actualIds.map((claimId, offset) => recordedIndex + offset + 1);
+}
+
+export async function reconstructFinishRetry({ store, workspaceId, session, message }) {
+  const events = await allEvents(store, workspaceId);
+  const recordedIndex = events.findIndex(event => event.type === "message.recorded"
+    && event.payload.messageId === message.messageId
+    && event.actorSessionId === session.sessionId);
+  if (session.state !== "closed" || recordedIndex === -1) throw conflict(message);
+
+  const laterOpen = events.slice(recordedIndex + 1).some(event =>
+    event.type === "session.opened" && event.actorSessionId === session.sessionId);
+  if (laterOpen) throw conflict(message);
+
+  const closedOffset = events.slice(recordedIndex + 1).findIndex(event =>
+    event.type === "session.closed" && event.actorSessionId === session.sessionId);
+  if (closedOffset === -1) throw conflict(message);
+  const closedIndex = recordedIndex + closedOffset + 1;
+  const releaseIndexes = correlatedReleaseIndexes(events, recordedIndex, closedIndex,
+    session, message);
+  const releasedClaims = releaseIndexes.map(index => claimProjection(events, index));
+  if (releasedClaims.includes(null)) throw conflict(message);
+  const snapshot = await store.snapshot(workspaceId, { kinds: ["claim"] });
+  if (snapshot.claims.some(claim => claim.ownerSessionId === session.sessionId)) {
+    throw conflict(message);
+  }
+  return releasedClaims;
+}

package/node_modules/@agents-can-communicate/core/src/inbox.mjs

@@ -1,134 +1,118 @@
-import { AccError, EXIT, SCHEMA_VERSION, advanceDelivery, createId, validateRecord }
+import { AccError, EXIT, SCHEMA_VERSION, advanceReceipt }
   from "@agents-can-communicate/protocol";
 
-const receiptId = (messageId, recipient) => `${messageId}--${recipient}`;
-const unresolved = (message, receipt) => receipt.state === "recorded"
-  || receipt.state === "queued"
-  || (message.requiresAck && (receipt.state === "injected" || receipt.state === "seen"));
+import { receiptId, recordMessageInTransaction } from "./conversations.mjs";
+
+const listable = (message, receipt) => receipt.state === "queued" || receipt.state === "offered"
+  || (receipt.state === "retrieved" && message.obligation !== "none");
 
-/** Narrow, recipient-owned message reads and replies. */
 export function createInboxService(ports, sessions) {
   const { store, clock, ids } = ports;
 
   async function requireOpen(input, action) {
-    const existing = await sessions.locateSession(input.sessionId, input.workspaceId);
-    if (existing === null || existing.record.state !== "open"
-      || existing.record.generation !== input.generation) {
+    const located = await sessions.locateSession(input.sessionId, input.workspaceId);
+    if (located === null || located.record.state !== "open"
+      || located.record.generation !== input.generation) {
       throw new AccError(EXIT.CONFLICT, `cannot ${action} from this session generation`,
         { sessionId: input.sessionId });
     }
-    return existing.record;
+    return located.record;
+  }
+
+  function requireOwnedReceipt(tx, session, messageId) {
+    const message = tx.get("message", messageId);
+    const id = receiptId(messageId, session.participantId);
+    const receipt = tx.get("receipt", id);
+    if (message === null || receipt === null) {
+      throw new AccError(EXIT.CONFLICT,
+        "that message is not addressed to this participant",
+        { messageId, participantId: session.participantId });
+    }
+    return { id, message, receipt };
+  }
+
+  function advanceOwned(tx, session, messageId, state, now) {
+    const owned = requireOwnedReceipt(tx, session, messageId);
+    const nextState = advanceReceipt(owned.receipt.state, state);
+    if (nextState === owned.receipt.state) {
+      return { message: owned.message, receipt: owned.receipt };
+    }
+    const receipt = { ...owned.receipt, state: nextState, updatedAt: now };
+    tx.put("receipt", owned.id, receipt, tx.generationOf("receipt", owned.id));
+    tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+      workspaceId: session.workspaceId, actorSessionId: session.sessionId,
+      type: `message.${state}`, occurredAt: now,
+      payload: { messageId, recipientParticipantId: session.participantId } });
+    return { message: owned.message, receipt };
   }
 
   async function readInbox(input) {
     const session = await requireOpen(input, "read the inbox");
-    const snapshot = await store.snapshot(session.workspaceId,
-      { kinds: ["message", "receipt"] });
-    const messages = new Map(snapshot.messages.map(message => [message.messageId, message]));
-    let addressed = snapshot.receipts
-      .filter(receipt => receipt.recipientParticipantId === session.participantId)
-      .map(receipt => ({ message: messages.get(receipt.messageId), receipt }))
-      .filter(item => item.message !== undefined);
-    if (input.messageId !== undefined) {
-      addressed = addressed.filter(item => item.message.messageId === input.messageId
-        && item.receipt.state !== "acknowledged" && item.receipt.state !== "failed");
-      if (addressed.length === 0) {
-        throw new AccError(EXIT.CONFLICT,
-          "that message is not recoverable by this participant",
-          { messageId: input.messageId, participantId: session.participantId });
+    const now = clock.now();
+    return store.transaction(tx => {
+      const messages = new Map(tx.list("message").map(item => [item.messageId, item]));
+      let selected = tx.list("receipt", receipt =>
+        receipt.recipientParticipantId === session.participantId)
+        .filter(receipt => messages.has(receipt.messageId));
+      if (input.messageId === undefined) {
+        selected = selected.filter(receipt => listable(messages.get(receipt.messageId), receipt));
+      } else {
+        selected = selected.filter(receipt => receipt.messageId === input.messageId
+          && receipt.state !== "acknowledged");
+        if (selected.length === 0) {
+          throw new AccError(EXIT.CONFLICT,
+            "that message is not recoverable by this participant",
+            { messageId: input.messageId, participantId: session.participantId });
+        }
       }
-    } else {
-      addressed = addressed.filter(item => unresolved(item.message, item.receipt));
-    }
-    addressed.sort((left, right) => left.message.sentAt.localeCompare(right.message.sentAt)
-      || left.message.messageId.localeCompare(right.message.messageId));
-    if (addressed.length === 0) return [];
+      selected.sort((left, right) => {
+        const a = messages.get(left.messageId);
+        const b = messages.get(right.messageId);
+        return a.sentAt.localeCompare(b.sentAt) || a.messageId.localeCompare(b.messageId);
+      });
+      return selected.map(receipt => advanceOwned(tx, session, receipt.messageId,
+        "retrieved", now));
+    }, { kinds: ["message", "receipt"] });
+  }
 
+  async function acknowledgeMessage(input) {
+    const session = await requireOpen(input, "acknowledge a message");
     const now = clock.now();
-    const shown = [];
-    await store.transaction(async tx => {
-      for (const item of addressed) {
-        const id = receiptId(item.message.messageId, session.participantId);
-        const current = tx.get("receipt", id);
-        const receipt = { ...current, state: advanceDelivery(current.state, "seen"),
-          updatedAt: now };
-        tx.put("receipt", id, receipt, tx.generationOf("receipt", id));
-        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-          workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-          type: "message.seen", occurredAt: now,
-          payload: { messageId: item.message.messageId,
-            recipientParticipantId: session.participantId } });
-        shown.push({ message: item.message, receipt });
-      }
-    }, { kinds: ["receipt"] });
-    return shown;
+    return store.transaction(tx => advanceOwned(tx, session, input.messageId,
+      "acknowledged", now).receipt,
+    { kinds: ["message", "receipt"] });
   }
 
   async function replyToMessage(input) {
     const session = await requireOpen(input, "reply to a message");
     const now = clock.now();
-    const replyId = createId("message");
-    let result = null;
-    await store.transaction(async tx => {
-      const original = tx.get("message", input.messageId);
-      const ownReceiptId = receiptId(input.messageId, session.participantId);
-      const originalReceipt = tx.get("receipt", ownReceiptId);
-      if (original === null || originalReceipt === null
-        || !original.toParticipantIds.includes(session.participantId)) {
-        throw new AccError(EXIT.CONFLICT,
-          "that message is not addressed to this participant",
-          { messageId: input.messageId, participantId: session.participantId });
-      }
-      if (originalReceipt.state === "acknowledged" || originalReceipt.state === "failed") {
+    const replyId = ids.next("message");
+    return store.transaction(tx => {
+      const original = requireOwnedReceipt(tx, session, input.messageId);
+      const matchingReply = tx.list("message", message =>
+        message.workspaceId === session.workspaceId
+        && message.fromParticipantId === session.participantId
+        && message.clientMessageId === input.clientMessageId).at(0);
+      if (original.receipt.state === "acknowledged" && matchingReply === undefined) {
         throw new AccError(EXIT.CONFLICT, "that message is already resolved",
-          { messageId: input.messageId, state: originalReceipt.state });
+          { messageId: input.messageId });
       }
-      const reply = validateRecord("message", {
-        schemaVersion: SCHEMA_VERSION,
-        messageId: replyId,
-        workspaceId: session.workspaceId,
-        fromSessionId: session.sessionId,
-        fromParticipantId: session.participantId,
-        toParticipantIds: [original.fromParticipantId],
-        type: input.type ?? "answer",
-        subject: input.subject ?? `Re: ${original.subject}`,
-        body: input.body,
-        priority: input.priority ?? "normal",
-        workstreamId: original.workstreamId,
-        taskId: original.taskId,
-        inReplyTo: original.messageId,
-        requiresAck: false,
-        artifacts: input.artifacts ?? [],
-        sentAt: now,
-      });
-      const acknowledged = { ...originalReceipt,
-        state: advanceDelivery(originalReceipt.state, "acknowledged"), updatedAt: now };
-      const replyReceipt = validateRecord("receipt", {
-        schemaVersion: SCHEMA_VERSION,
-        messageId: replyId,
-        workspaceId: session.workspaceId,
-        recipientParticipantId: original.fromParticipantId,
-        state: "queued",
-        updatedAt: now,
-      });
-      tx.put("message", replyId, reply);
-      tx.put("receipt", receiptId(replyId, original.fromParticipantId), replyReceipt);
-      tx.put("receipt", ownReceiptId, acknowledged,
-        tx.generationOf("receipt", ownReceiptId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-        type: "message.sent", occurredAt: now,
-        payload: { messageId: replyId, type: reply.type,
-          recipients: reply.toParticipantIds } });
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-        type: "message.acknowledged", occurredAt: now,
-        payload: { messageId: original.messageId,
-          recipientParticipantId: session.participantId } });
-      result = { reply, receipt: acknowledged };
-    }, { kinds: ["message", "receipt"] });
-    return result;
+      const recorded = recordMessageInTransaction({ tx, session, now, messageId: replyId, ids,
+        action: "reply to a message", input: {
+          clientMessageId: input.clientMessageId,
+          toParticipantIds: [original.message.fromParticipantId],
+          kind: "answer",
+          obligation: "none",
+          subject: input.subject ?? `Re: ${original.message.subject}`,
+          body: input.body,
+          inReplyTo: original.message.messageId,
+          artifacts: input.artifacts ?? [],
+          handoff: null,
+        } });
+      const receipt = advanceOwned(tx, session, input.messageId, "acknowledged", now).receipt;
+      return { reply: recorded.message, receipt };
+    }, { kinds: ["participant", "session", "message", "receipt"] });
   }
 
-  return { readInbox, replyToMessage };
+  return { readInbox, replyToMessage, acknowledgeMessage };
 }

package/node_modules/@agents-can-communicate/core/src/index.mjs

@@ -3,7 +3,7 @@ export { createCoordinationService } from "./service.mjs";
 export { assertPorts } from "./ports.mjs";
 export { classifySessionPresence } from "./sessions.mjs";
 export { defaultPidIsAlive } from "./pid.mjs";
-export { ATTENTION_PRIORITY, computeAttention } from "./sync.mjs";
-export { looksConsequential, noteNudge } from "./message-signals.mjs";
+export { ATTENTION_PRIORITY, computeAttention } from "./attention.mjs";
+export { SAFE_OFFER_ERROR_CODES } from "./receipts.mjs";
+export { createDeliveryBindingService } from "./delivery-bindings.mjs";
 export { overlaps } from "./claims.mjs";
-export { wouldCycle } from "./tasks.mjs";

package/node_modules/@agents-can-communicate/core/src/intents.mjs

@@ -35,7 +35,6 @@ export function createIntentService(ports, sessions) {
       summary: input.summary,
       mode: input.mode,
       resourceHints: input.resourceHints ?? [],
-      workstreamId: input.workstreamId ?? null,
       state: input.state ?? "active",
       updatedAt: now,
     });

package/node_modules/@agents-can-communicate/core/src/ports.mjs

@@ -8,7 +8,8 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  *   list(kind: string, predicate?: (record: object) => boolean): object[],
  *   put(kind: string, id: string, record: object, expectedGeneration?: string | null): string,
  *   append(event: object): object }} CoordinationTransaction
- * @typedef {{ transaction(callback: (tx: CoordinationTransaction) => unknown): Promise<unknown>,
+ * @typedef {{ transaction(callback: (tx: CoordinationTransaction) => unknown,
+ *   options?: { kinds?: string[], deadlineAt?: number }): Promise<unknown>,
  *   eventsSince(workspaceId: string, cursor: string | null, limit: number): Promise<object>,
  *   snapshot(workspaceId: string): Promise<object> }} CoordinationStore
  */

package/node_modules/@agents-can-communicate/core/src/receipts.mjs

@@ -0,0 +1,109 @@
+import { AccError, EXIT, SCHEMA_VERSION, advanceReceipt }
+  from "@agents-can-communicate/protocol";
+
+import { receiptId } from "./conversations.mjs";
+
+export const SAFE_OFFER_ERROR_CODES = Object.freeze([
+  "ambiguous_recipient_sessions",
+  "delivery_disabled",
+  "recipient_busy",
+  "recipient_unavailable",
+  "transport_error",
+  "transport_rejected",
+  "unsupported_client_version",
+]);
+
+function missingReceipt(messageId, recipientParticipantId) {
+  return new AccError(EXIT.CONFLICT, "no receipt exists for that recipient",
+    { messageId, recipientParticipantId });
+}
+
+function requireReceipt(tx, messageId, recipientParticipantId) {
+  const receipt = tx.get("receipt", receiptId(messageId, recipientParticipantId));
+  if (receipt === null) throw missingReceipt(messageId, recipientParticipantId);
+  const message = tx.get("message", messageId);
+  if (message === null) throw missingReceipt(messageId, recipientParticipantId);
+  return { message, receipt };
+}
+
+function requireOfferableReceipt(tx, input, { allowRoomNextTurn }) {
+  const found = requireReceipt(tx, input.messageId, input.recipientParticipantId);
+  if (found.message.toParticipantIds.length === 0
+    && (!allowRoomNextTurn || input.transport !== "next-turn")) {
+    throw new AccError(EXIT.CONFLICT, "room messages are not eligible for live offers",
+      { messageId: input.messageId, recipientParticipantId: input.recipientParticipantId });
+  }
+  return found.receipt;
+}
+
+function requireTarget(tx, input, { mustBeOpen }) {
+  const target = tx.get("session", input.targetSessionId);
+  if (target === null || (mustBeOpen && target.state !== "open")
+    || target.participantId !== input.recipientParticipantId
+    || target.generation !== input.targetGeneration) {
+    throw new AccError(EXIT.CONFLICT,
+      "the offer target is not this recipient's session generation",
+      { targetSessionId: input.targetSessionId,
+        recipientParticipantId: input.recipientParticipantId });
+  }
+  return target;
+}
+
+export function createReceiptService(ports) {
+  const { store, clock, ids } = ports;
+
+  async function readReceipt(input) {
+    return store.transaction(tx => requireReceipt(tx, input.messageId,
+      input.recipientParticipantId).receipt, { kinds: ["message", "receipt"] });
+  }
+
+  async function recordOfferSucceeded(input) {
+    const now = clock.now();
+    return store.transaction(tx => {
+      const id = receiptId(input.messageId, input.recipientParticipantId);
+      const receipt = requireOfferableReceipt(tx, input, { allowRoomNextTurn: true });
+      const target = requireTarget(tx, input, { mustBeOpen: true });
+      // A retrieval or acknowledgement may win after a transport accepted but
+      // before this transaction acquired the writer. That stronger truth must
+      // remain in place. The same rule makes a repeated successful commit a
+      // read-only operation rather than another success event.
+      if (receipt.state !== "queued") return receipt;
+      const offered = { ...receipt, state: advanceReceipt(receipt.state, "offered"),
+        updatedAt: now };
+      tx.put("receipt", id, offered, tx.generationOf("receipt", id));
+      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: receipt.workspaceId, actorSessionId: target.sessionId,
+        type: "message.offer_succeeded", occurredAt: now,
+        payload: { messageId: input.messageId,
+          recipientParticipantId: input.recipientParticipantId,
+          targetSessionId: input.targetSessionId,
+          targetGeneration: input.targetGeneration,
+          transport: input.transport, adapterId: input.adapterId,
+          clientVersion: input.clientVersion } });
+      return offered;
+    }, { kinds: ["session", "message", "receipt"], deadlineAt: input.deadlineAt });
+  }
+
+  async function recordOfferFailed(input) {
+    if (!SAFE_OFFER_ERROR_CODES.includes(input.safeErrorCode)) {
+      throw new AccError(EXIT.DATA, "safeErrorCode is not in the closed offer error set",
+        { safeErrorCode: input.safeErrorCode });
+    }
+    const now = clock.now();
+    return store.transaction(tx => {
+      const receipt = requireOfferableReceipt(tx, input, { allowRoomNextTurn: false });
+      const target = requireTarget(tx, input, { mustBeOpen: false });
+      return tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: receipt.workspaceId, actorSessionId: target.sessionId,
+        type: "message.offer_failed", occurredAt: now,
+        payload: { messageId: input.messageId,
+          recipientParticipantId: input.recipientParticipantId,
+          targetSessionId: target.sessionId,
+          targetGeneration: target.generation,
+          transport: input.transport, adapterId: input.adapterId,
+          clientVersion: input.clientVersion, safeErrorCode: input.safeErrorCode } });
+    }, { kinds: ["session", "message", "receipt"] });
+  }
+
+  return { readReceipt, recordOfferSucceeded, recordOfferFailed };
+}

package/node_modules/@agents-can-communicate/core/src/service.mjs

@@ -1,14 +1,14 @@
 import { createClaimService } from "./claims.mjs";
-import { createCommunicationService } from "./communication.mjs";
+import { createConversationService } from "./conversations.mjs";
+import { createDeliveryBindingService } from "./delivery-bindings.mjs";
 import { createIntentService } from "./intents.mjs";
 import { createInboxService } from "./inbox.mjs";
 import { defaultPidIsAlive } from "./pid.mjs";
 import { assertPorts } from "./ports.mjs";
+import { createReceiptService } from "./receipts.mjs";
 import { createSessionService } from "./sessions.mjs";
 import { createGuardStateService, createStatusService } from "./status.mjs";
 import { createSyncService } from "./sync.mjs";
-import { createTaskService } from "./tasks.mjs";
-import { createWorkstreamService } from "./workstreams.mjs";
 
 /**
  * Composition root for the domain services. Everything time- or
@@ -29,13 +29,13 @@ export function createCoordinationService({ store, clock, ids,
   const ports = assertPorts({ store, clock, ids, pidIsAlive });
   const sessions = createSessionService(ports);
   const intents = createIntentService(ports, sessions);
-  const workstreams = createWorkstreamService(ports, sessions);
-  const tasks = createTaskService(ports, workstreams);
   const claims = createClaimService(ports, sessions);
-  const communication = createCommunicationService(ports, sessions, claims);
+  const conversations = createConversationService(ports, sessions);
+  const deliveryBindings = createDeliveryBindingService(ports, sessions);
   const inbox = createInboxService(ports, sessions);
+  const receipts = createReceiptService(ports);
   const sync = createSyncService(ports, sessions);
-  const status = createStatusService(ports, sessions);
+  const status = createStatusService(ports, sessions, deliveryBindings);
   const guardState = createGuardStateService(ports);
   return Object.freeze({
     store,
@@ -44,11 +44,12 @@ export function createCoordinationService({ store, clock, ids,
     policies: Object.freeze({ ...policies }),
     ...sessions,
     ...intents,
-    ...workstreams,
-    ...tasks,
     ...claims,
-    ...communication,
+    ...conversations,
+    publishDeliveryBinding: deliveryBindings.publishDeliveryBinding,
+    listDeliveryBindings: deliveryBindings.listDeliveryBindings,
     ...inbox,
+    ...receipts,
     ...sync,
     ...status,
     guardState,