@matter/protocol 0.16.0-alpha.0-20251016-b56cf5683 → 0.16.0-alpha.0-20251018-dd1ea6a8a

package/src/action/request/Specifier.ts

@@ -41,7 +41,7 @@ export namespace Specifier {
     export type Command<C extends ClusterType = ClusterType> = ClusterType.Command | (string & keyof C["commands"]);
 
     /**
-     * An event specifier may be the name of a cluser event or an event object.
+     * An event specifier may be the name of a cluster event or an event object.
      */
     export type Event<C extends ClusterType = ClusterType> = ClusterType.Event | (string & keyof C["events"]);
 
@@ -97,6 +97,26 @@ export namespace Specifier {
           ? CMD
           : never;
 
+    export function commandFor<const C extends ClusterType, const CMD extends Specifier.Command<C>>(
+        cluster: C | undefined,
+        specifier: CMD,
+    ): CommandFor<C, CMD> {
+        if (typeof specifier !== "string") {
+            return specifier as CommandFor<C, CMD>;
+        }
+
+        if (cluster === undefined) {
+            throw new MalformedRequestError(`Cannot designate command "${specifier}" without a cluster`);
+        }
+
+        const command = cluster.commands?.[specifier];
+        if (command === undefined) {
+            throw new MalformedRequestError(`Cluster ${cluster.name} does not define command ${specifier}`);
+        }
+
+        return command as CommandFor<C, CMD>;
+    }
+
     /**
      * Extract an event object from a cluster and event specifier.
      */
@@ -144,3 +164,62 @@ export namespace Specifier {
         return request.endpoint?.number;
     }
 }
+
+export function toWildcardOrHexPath(name: string, value: number | bigint | undefined) {
+    if (value === undefined) {
+        return "*";
+    }
+    return `${name ? `${name}:` : ""}0x${value.toString(16)}`;
+}
+
+/**
+ * Resolve a path into a human readable textual form for logging
+ * TODO: Add a Diagnostic display formatter for this
+ */
+export function resolvePathForSpecifier<const C extends ClusterType>(location: {
+    endpoint?: Specifier.Endpoint;
+    cluster?: Specifier.Cluster;
+    attribute?: Specifier.Attribute<Specifier.ClusterFor<C>>;
+    event?: Specifier.Event<Specifier.ClusterFor<C>>;
+    command?: Specifier.Command<Specifier.ClusterFor<C>>;
+    isUrgent?: boolean;
+    listIndex?: number | null;
+}) {
+    const endpointId = Specifier.endpointIdOf(location);
+    const cluster = location.cluster ? Specifier.clusterFor(location.cluster) : undefined;
+    const attribute = location.attribute && cluster ? Specifier.attributeFor(cluster, location.attribute) : undefined;
+    const event = location.event && cluster ? Specifier.eventFor(cluster, location.event) : undefined;
+    const command = location.command && cluster ? Specifier.commandFor(cluster, location.command) : undefined;
+    const isUrgentString = "isUrgent" in location && location.isUrgent ? "!" : "";
+    const listIndexString = "listIndex" in location && location.listIndex === null ? "[ADD]" : "";
+    const postString = `${listIndexString}${isUrgentString}`;
+
+    const clusterId = cluster?.id;
+    const elementId = attribute ? attribute.id : event ? event.id : command ? command.requestId : undefined;
+
+    if (endpointId === undefined) {
+        return `*.${toWildcardOrHexPath("", clusterId)}.${toWildcardOrHexPath("", elementId)}${postString}`;
+    }
+
+    const endpointName = toWildcardOrHexPath("", endpointId);
+
+    if (cluster === undefined || clusterId === undefined) {
+        return `${endpointName}.*.${toWildcardOrHexPath("", elementId)}${postString}`;
+    }
+
+    const clusterName = toWildcardOrHexPath(cluster.name, clusterId);
+
+    if (elementId !== undefined) {
+        if (event) {
+            return `${endpointName}.${clusterName}.${toWildcardOrHexPath(typeof location.event === "string" ? location.event : "?", elementId)}${postString}`;
+        } else if (attribute) {
+            return `${endpointName}.${clusterName}.${toWildcardOrHexPath(typeof location.attribute === "string" ? location.attribute : "?", elementId)}${postString}`;
+        } else if (command) {
+            return `${endpointName}.${clusterName}.${toWildcardOrHexPath(typeof location.command === "string" ? location.command : "?", elementId)}${postString}`;
+        } else {
+            return "unknown";
+        }
+    } else {
+        return `${endpointName}.${clusterName}.*${postString}`;
+    }
+}

package/src/action/request/Write.ts

@@ -4,14 +4,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { FALLBACK_INTERACTIONMODEL_REVISION } from "#session/Session.js";
-import { AttributeData, ClusterType, WriteRequest } from "#types";
+import { AccessControl } from "#clusters/access-control";
+import { Diagnostic, Duration } from "#general";
+import { Specification } from "#model";
+import { ArraySchema, AttributeData, AttributeId, ClusterId, ClusterType, WriteRequest } from "#types";
 import { MalformedRequestError } from "./MalformedRequestError.js";
-import { Specifier } from "./Specifier.js";
+import { resolvePathForSpecifier, Specifier } from "./Specifier.js";
+
+const AclClusterId = AccessControl.Complete.id;
+const AclAttributeId = AccessControl.Complete.attributes.acl.id;
+const AclExtensionAttributeId = AccessControl.Complete.attributes.extension.id;
+
+function isAclOrExtensionPath(path: { clusterId: ClusterId; attributeId: AttributeId }) {
+    const { clusterId, attributeId } = path;
+    return clusterId === AclClusterId && (attributeId === AclAttributeId || attributeId === AclExtensionAttributeId);
+}
 
 export interface Write extends WriteRequest {
-    /** Timeout only relevant for Client Interactions */
-    timeout?: number;
+    /** Timeout only relevant for Client Interactions with a required TimedRequest flagging */
+    timeout?: Duration;
 }
 
 /**
@@ -41,13 +52,25 @@ export function Write(optionsOrData: Write.Options | Write.Attribute, ...data: W
     } else {
         options = optionsOrData;
     }
-    const { writes: writeRequests = [] } = options;
+    const { writes: writeRequests = [], timed, timeout, chunkLists } = options;
 
-    const result: Write = {
-        timedRequest: !!options.timed || !!options.timeout,
+    const result = {
+        timedRequest: !!timed || !!timeout,
+        timeout,
         writeRequests,
-        interactionModelRevision: options.interactionModelRevision ?? FALLBACK_INTERACTIONMODEL_REVISION,
-    };
+        moreChunkedMessages: false,
+        interactionModelRevision: options.interactionModelRevision ?? Specification.INTERACTION_MODEL_REVISION,
+
+        [Diagnostic.value]: () =>
+            Diagnostic.list(
+                data.map(entry => {
+                    const { version, value } = entry;
+                    return `${resolvePathForSpecifier(entry)} = ${Diagnostic.json(
+                        value,
+                    )}${version !== undefined ? `(version=${version})` : ""}`;
+                }),
+            ),
+    } as Write;
 
     for (const entry of data) {
         reifyData(entry);
@@ -87,15 +110,43 @@ export function Write(optionsOrData: Write.Options | Write.Attribute, ...data: W
         };
 
         for (const specifier of attributes) {
+            const clusterId = cluster.id;
             const attribute = Specifier.attributeFor(cluster, specifier);
-            writeRequests.push({
-                ...prototype,
-                path: {
-                    ...prototype.path,
-                    attributeId: attribute.id,
-                },
-                data: attribute.schema.encodeTlv(value, { forWriteInteraction: true }),
-            });
+            const { schema, id: attributeId } = attribute;
+
+            if (
+                chunkLists &&
+                Array.isArray(value) &&
+                schema instanceof ArraySchema &&
+                // As implemented for Matter 1.4.2 in https://github.com/project-chip/connectedhomeip/pull/38263
+                // Acl writes will no longer be chunked by default, all others still
+                // Will be streamlined later ... see https://github.com/project-chip/connectedhomeip/issues/38270
+                !isAclOrExtensionPath({ clusterId, attributeId })
+            ) {
+                writeRequests.push(
+                    ...schema
+                        .encodeAsChunkedArray(value, { forWriteInteraction: true })
+                        .map(({ element: data, listIndex }) => ({
+                            path: {
+                                ...prototype.path,
+                                attributeId: attribute.id,
+                                listIndex,
+                            },
+                            data,
+                            dataVersion,
+                        })),
+                );
+            } else {
+                writeRequests.push({
+                    ...prototype,
+                    path: {
+                        ...prototype.path,
+                        attributeId: attribute.id,
+                    },
+                    data: attribute.schema.encodeTlv(value, { forWriteInteraction: true }),
+                });
+            }
+            result.timedRequest ||= attribute.timed;
         }
     }
 }
@@ -104,8 +155,9 @@ export namespace Write {
     export interface Options {
         writes?: AttributeData[];
         timed?: boolean;
-        timeout?: number;
+        timeout?: Duration;
         interactionModelRevision?: number;
+        chunkLists?: boolean;
     }
 
     /**

package/src/action/response/InvokeResult.ts

@@ -8,10 +8,14 @@ import type { ClusterId, CommandId, CommandPath, EndpointNumber, StatusCode, Tlv
 
 export type InvokeResult = AsyncIterable<InvokeResult.Chunk>;
 
+export type DecodedInvokeResult = AsyncIterable<InvokeResult.DecodedChunk>;
+
 export namespace InvokeResult {
     export type Chunk = Iterable<Data>;
+    export type DecodedChunk = Iterable<DecodedData>;
 
     export type Data = CommandStatus | CommandResponse;
+    export type DecodedData = CommandStatus | DecodedCommandResponse;
 
     export interface ConcreteCommandPath extends CommandPath {
         endpointId: EndpointNumber;
@@ -33,4 +37,8 @@ export namespace InvokeResult {
         commandRef?: number;
         data: TlvStream;
     }
+
+    export interface DecodedCommandResponse extends Omit<CommandResponse, "data"> {
+        data: any;
+    }
 }

package/src/interaction/InteractionClient.ts

@@ -383,26 +383,6 @@ export class InteractionClient {
             );
         }
 
-        logger.debug(
-            `Sending read request: attributes: ${attributeRequests
-                ?.map(path => resolveAttributeName(path))
-                .join(", ")} and events: ${eventRequests?.map(path => resolveEventName(path)).join(", ")}`,
-        );
-        if (dataVersionFilters !== undefined && dataVersionFilters?.length > 0) {
-            logger.debug(
-                `Using DataVersionFilters: ${dataVersionFilters
-                    .map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`)
-                    .join(", ")}`,
-            );
-        }
-        if (eventFilters !== undefined && eventFilters?.length > 0) {
-            logger.debug(
-                `Using event filters: ${eventFilters
-                    .map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`)
-                    .join(", ")}`,
-            );
-        }
-
         const result = await this.withMessenger(async messenger => {
             return await this.processReadRequest(
                 messenger,
@@ -560,12 +540,32 @@ export class InteractionClient {
             oldValue?: any,
         ) => void,
     ): Promise<DecodedDataReport> {
-        const { attributeRequests, eventRequests } = request;
-        logger.debug(
-            `Sending read request to ${messenger.getExchangeChannelName()} for attributes ${attributeRequests
-                ?.map(path => resolveAttributeName(path))
-                .join(", ")} and events ${eventRequests?.map(path => resolveEventName(path)).join(", ")}`,
-        );
+        const { attributeRequests, eventRequests, dataVersionFilters, eventFilters, isFabricFiltered } = request;
+        logger.debug(() => [
+            "Read »",
+            messenger.exchange.via,
+            Diagnostic.dict({
+                attributes: attributeRequests?.length
+                    ? attributeRequests?.map(path => resolveAttributeName(path)).join(", ")
+                    : undefined,
+                events: eventRequests?.length
+                    ? eventRequests?.map(path => resolveEventName(path)).join(", ")
+                    : undefined,
+                dataVersionFilters: dataVersionFilters?.length
+                    ? dataVersionFilters
+                          .map(
+                              ({ path: { endpointId, clusterId }, dataVersion }) =>
+                                  `${endpointId}/${clusterId}=${dataVersion}`,
+                          )
+                          .join(", ")
+                    : undefined,
+                eventFilters: eventFilters?.length
+                    ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")
+                    : undefined,
+                fabricFiltered: isFabricFiltered,
+            }),
+        ]);
+
         // Send read request and combine all (potentially chunked) responses
         await messenger.sendReadRequest(request);
         const scope = ReadScope(request);
@@ -576,24 +576,32 @@ export class InteractionClient {
         // Normalize and decode the response
         const { attributeReports, attributeStatus, eventReports, eventStatus } = response;
 
-        const logData = Array<string>();
-        if (attributeReports.length > 0) {
-            logData.push(
-                `attributes ${attributeReports.map(({ path, value }) => `${resolveAttributeName(path)}=${serialize(value)}`).join(", ")}`,
-            );
-        }
-        if (eventReports.length > 0) {
-            logData.push(`events ${eventReports.map(({ path }) => resolveEventName(path)).join(", ")}`);
+        if (attributeReports.length || eventReports.length || attributeStatus?.length || eventStatus?.length) {
+            logger.debug(() => [
+                "Read «",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: attributeReports.length
+                        ? attributeReports
+                              .map(({ path, value }) => `${resolveAttributeName(path)}=${serialize(value)}`)
+                              .join(", ")
+                        : undefined,
+                    events: eventReports.length
+                        ? eventReports.map(({ path }) => resolveEventName(path)).join(", ")
+                        : undefined,
+                    attributeStatus: attributeStatus?.length
+                        ? attributeStatus.map(({ path }) => resolveAttributeName(path)).join(", ")
+                        : undefined,
+                    eventStatus: eventStatus?.length
+                        ? eventStatus.map(({ path }) => resolveEventName(path)).join(", ")
+                        : undefined,
+                    fabricFiltered: isFabricFiltered,
+                }),
+            ]);
+        } else {
+            logger.debug("Read «", messenger.exchange.via, "empty response");
         }
-        if (attributeStatus !== undefined && attributeStatus.length > 0) {
-            logData.push(`attributeErrors ${attributeStatus.map(({ path }) => resolveAttributeName(path)).join(", ")}`);
-        }
-        if (eventStatus !== undefined && eventStatus.length > 0) {
-            logData.push(`eventErrors ${eventStatus.map(({ path }) => resolveEventName(path)).join(", ")}`);
-        }
-        logger.debug(
-            logData.length ? `Received read response with ${logData.join(", ")}` : "Received empty read response",
-        );
+
         return response;
     }
 
@@ -674,16 +682,7 @@ export class InteractionClient {
                 throw new ImplementationError("Not all attribute write paths are valid for group address writes.");
             }
         }
-        logger.debug(
-            `Sending write request: ${attributes
-                .map(
-                    ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) =>
-                        `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Diagnostic.json(
-                            value,
-                        )} (version=${dataVersion})`,
-                )
-                .join(", ")}`,
-        );
+
         // TODO Add multi message write handling with streamed encoding
         const writeRequests = attributes.flatMap(
             ({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => {
@@ -727,6 +726,21 @@ export class InteractionClient {
                     await messenger.sendTimedRequest(timedRequestTimeout);
                 }
 
+                logger.debug(() => [
+                    "Write »",
+                    messenger.exchange.via,
+                    Diagnostic.dict({
+                        attributes: attributes
+                            .map(
+                                ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) =>
+                                    `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Diagnostic.json(
+                                        value,
+                                    )} (version=${dataVersion})`,
+                            )
+                            .join(", "),
+                    }),
+                ]);
+
                 return await messenger.sendWriteCommand({
                     suppressResponse,
                     timedRequest,
@@ -798,14 +812,6 @@ export class InteractionClient {
             }
         }
 
-        logger.debug(
-            `Sending subscribe request for attribute: ${resolveAttributeName({
-                endpointId,
-                clusterId,
-                attributeId,
-            })}${knownDataVersion !== undefined ? ` (knownDataVersion=${knownDataVersion})` : ""} with minInterval=${minIntervalFloorSeconds}s/maxInterval=${maxIntervalCeilingSeconds}s`,
-        );
-
         const request: SubscribeRequest = {
             interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
             attributeRequests: [{ endpointId, clusterId, attributeId }],
@@ -829,6 +835,18 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: resolveAttributeName({ endpointId, clusterId, attributeId }),
+                    dataVersionFilter: knownDataVersion,
+                    fabricFiltered: isFabricFiltered,
+                    minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
+                    maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds)),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest(request);
             const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse();
             return {
@@ -913,10 +931,6 @@ export class InteractionClient {
         } = options;
         const { id: eventId } = event;
 
-        logger.debug(
-            `Sending subscribe request for event: ${resolveEventName({ endpointId, clusterId, eventId })} with minInterval=${minIntervalFloor}/maxInterval=${maxIntervalCeiling}`,
-        );
-
         const {
             report,
             subscribeResponse: { subscriptionId, maxInterval },
@@ -926,6 +940,17 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    events: resolveEventName({ endpointId, clusterId, eventId }),
+                    fabricFiltered: isFabricFiltered,
+                    minInterval: Duration.format(minIntervalFloor),
+                    maxInterval: Duration.format(maxIntervalCeiling),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest({
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                 eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
@@ -1060,28 +1085,6 @@ export class InteractionClient {
             }
         }
 
-        logger.debug(
-            `Sending subscribe request: attributes: ${attributeRequests
-                .map(path => resolveAttributeName(path))
-                .join(
-                    ", ",
-                )} and events: ${eventRequests.map(path => resolveEventName(path)).join(", ")}, keepSubscriptions=${keepSubscriptions} with minInterval=${minIntervalFloorSeconds}s/maxInterval=${maxIntervalCeilingSeconds}s`,
-        );
-        if (dataVersionFilters !== undefined && dataVersionFilters?.length > 0) {
-            logger.debug(
-                `Using DataVersionFilters: ${dataVersionFilters
-                    .map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`)
-                    .join(", ")}`,
-            );
-        }
-        if (eventFilters !== undefined && eventFilters?.length > 0) {
-            logger.debug(
-                `Using event filters: ${eventFilters
-                    .map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`)
-                    .join(", ")}`,
-            );
-        }
-
         const request: SubscribeRequest = {
             interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
             attributeRequests,
@@ -1108,10 +1111,48 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: attributeRequests.length
+                        ? attributeRequests.map(path => resolveAttributeName(path)).join(", ")
+                        : undefined,
+                    events: eventRequests.length
+                        ? eventRequests.map(path => resolveEventName(path)).join(", ")
+                        : undefined,
+                    dataVersionFilter: dataVersionFilters?.length
+                        ? dataVersionFilters
+                              .map(
+                                  ({ endpointId, clusterId, dataVersion }) =>
+                                      `${endpointId}/${clusterId}=${dataVersion}`,
+                              )
+                              .join(", ")
+                        : undefined,
+                    eventFilters: eventFilters?.length
+                        ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")
+                        : undefined,
+                    fabricFiltered: isFabricFiltered,
+                    keepSubscriptions,
+                    minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
+                    maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds)),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest(request);
             const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse(attributeReports =>
                 this.processAttributeUpdates(scope, attributeReports, attributeListener),
             );
+
+            logger.info(
+                "Subscription successful «",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    subId: subscribeResponse.subscriptionId,
+                    maxInterval: Duration.format(Seconds(subscribeResponse.maxInterval)),
+                }),
+            );
+
             return {
                 subscribeResponse,
                 report,
@@ -1119,8 +1160,6 @@ export class InteractionClient {
             };
         }, executeQueued);
 
-        logger.info(`Subscription successfully initialized with ID ${subscriptionId} and maxInterval ${maxInterval}s.`);
-
         const subscriptionListener = async (dataReport: {
             attributeReports?: DecodedAttributeReportValue<any>[];
             eventReports?: DecodedEventReportValue<any>[];
@@ -1139,9 +1178,7 @@ export class InteractionClient {
             if (eventReports !== undefined) {
                 let maxEventNumber = this.#nodeStore?.maxEventNumber ?? eventReports[0].events[0].eventNumber;
                 eventReports.forEach(data => {
-                    logger.debug(
-                        `Received event update: ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`,
-                    );
+                    logger.debug(`Event update « ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`);
                     const { events } = data;
 
                     maxEventNumber =
@@ -1202,7 +1239,9 @@ export class InteractionClient {
                 version,
             } = data;
 
-            if (value === undefined) throw new MatterFlowError("Received empty subscription result value.");
+            if (value === undefined) {
+                throw new MatterFlowError("Received empty subscription result value.");
+            }
             const { value: oldValue, version: oldVersion } =
                 this.#nodeStore?.retrieveAttribute(endpointId, clusterId, attributeId) ?? {};
             const changed = oldValue !== undefined ? !isDeepEqual(oldValue, value) : undefined;
@@ -1210,7 +1249,7 @@ export class InteractionClient {
                 await this.#nodeStore?.persistAttributes([data], scope);
             }
             logger.debug(
-                `Received attribute update${changed ? "(value changed)" : ""}: ${resolveAttributeName({
+                `Attribute update «${changed ? " (value changed)" : ""}: ${resolveAttributeName({
                     endpointId,
                     clusterId,
                     attributeId,
@@ -1355,7 +1394,7 @@ export class InteractionClient {
             }
             const response = responseSchema.decodeTlv(commandFields);
             logger.debug(
-                `Received invoke response: ${resolveCommandName({
+                `Invoke « ${resolveCommandName({
                     endpointId,
                     clusterId,
                     commandId: requestId,
@@ -1429,7 +1468,7 @@ export class InteractionClient {
         }, executeQueued);
 
         logger.debug(
-            `Invoke successful: ${resolveCommandName({
+            `Invoke successful « ${resolveCommandName({
                 endpointId,
                 clusterId,
                 commandId: requestId,

package/src/interaction/InteractionMessenger.ts

@@ -105,7 +105,19 @@ const DATA_REPORT_MAX_QUEUED_ATTRIBUTE_MESSAGES = 20;
 const DATA_REPORT_MIN_AVAILABLE_BYTES_BEFORE_SENDING = 40;
 
 class InteractionMessenger {
-    constructor(protected exchange: MessageExchange) {}
+    #exchange: MessageExchange;
+
+    constructor(exchange: MessageExchange) {
+        this.#exchange = exchange;
+    }
+
+    get exchange() {
+        return this.#exchange;
+    }
+
+    protected set exchange(value: MessageExchange) {
+        this.#exchange = value;
+    }
 
     send(messageType: number, payload: Bytes, options?: ExchangeSendOptions) {
         return this.exchange.send(messageType, payload, options);
@@ -197,8 +209,8 @@ class InteractionMessenger {
             );
     }
 
-    getExchangeChannelName() {
-        return this.exchange.channel.name;
+    get session() {
+        return this.exchange.session;
     }
 }