@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/src/client.ts

@@ -223,6 +223,7 @@ import { type CryptoBackend } from "./common-crypto/CryptoBackend.ts";
 import { RUST_SDK_STORE_PREFIX } from "./rust-crypto/constants.ts";
 import {
     type CrossSigningKeyInfo,
+    type CrossSigningKeys,
     type CryptoApi,
     type CryptoCallbacks,
     CryptoEvent,
@@ -249,6 +250,7 @@ import {
 import { type EmptyObject } from "./@types/common.ts";
 import { UnsupportedDelayedEventsEndpointError, UnsupportedStickyEventsEndpointError } from "./errors.ts";
 import { type Transport } from "./matrixrtc/index.ts";
+import { RetentionPolicyService } from "./retentionPolicy.ts";
 
 export type Store = IStore;
 
@@ -462,6 +464,11 @@ export interface ICreateClientOpts {
      * Defaults to the built-in global logger; see {@link DebugLogger} for an alternative.
      */
     logger?: Logger;
+
+    /**
+     * Locally remove events past the server global or per room retention setting.
+     */
+    unstableMSC1763Retention?: boolean;
 }
 
 export interface IMatrixClientCreateOpts extends ICreateClientOpts {
@@ -564,14 +571,6 @@ export const UNSTABLE_MSC4354_STICKY_EVENTS = "org.matrix.msc4354";
 export const UNSTABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133";
 export const STABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133.stable";
 
-enum CrossSigningKeyType {
-    MasterKey = "master_key",
-    SelfSigningKey = "self_signing_key",
-    UserSigningKey = "user_signing_key",
-}
-
-export type CrossSigningKeys = Record<CrossSigningKeyType, CrossSigningKeyInfo>;
-
 export type SendToDeviceContentMap = Map<string, Map<string, Record<string, any>>>;
 
 export interface ISignedKey {
@@ -582,6 +581,9 @@ export interface ISignedKey {
     device_id: string;
 }
 
+// re-export for backwards compatibility
+export { type CrossSigningKeys };
+
 export type KeySignatures = Record<string, Record<string, CrossSigningKeyInfo | ISignedKey>>;
 export interface IUploadKeySignaturesResponse {
     failures: Record<
@@ -1327,6 +1329,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public readonly matrixRTC: MatrixRTCSessionManager;
 
     private serverCapabilitiesService: ServerCapabilities;
+    public readonly retentionPolicyService: RetentionPolicyService;
+    // eslint-disable-next-line
+    public readonly _unstable_shouldApplyMessageRetention: boolean;
 
     public constructor(opts: IMatrixClientCreateOpts) {
         super();
@@ -1405,6 +1410,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.matrixRTC = new MatrixRTCSessionManager(this.logger, this);
 
         this.serverCapabilitiesService = new ServerCapabilities(this.logger, this.http);
+        this.retentionPolicyService = new RetentionPolicyService(this.logger, this.http);
+        this._unstable_shouldApplyMessageRetention = opts.unstableMSC1763Retention ?? false;
 
         this.on(ClientEvent.Sync, this.fixupRoomNotifications);
 
@@ -1479,10 +1486,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // periodically poll for turn servers if we support voip
         if (this.supportsVoip()) {
             this.checkTurnServersIntervalID = setInterval(() => {
-                this.checkTurnServers();
+                void this.checkTurnServers();
             }, TURN_CHECK_INTERVAL);
-            // noinspection ES6MissingAwait
-            this.checkTurnServers();
+            void this.checkTurnServers();
         }
 
         if (this.syncApi) {
@@ -1523,13 +1529,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         if (this.clientOpts.clientWellKnownPollPeriod !== undefined) {
             this.clientWellKnownIntervalID = setInterval(() => {
-                this.fetchClientWellKnown();
+                void this.fetchClientWellKnown();
             }, 1000 * this.clientOpts.clientWellKnownPollPeriod);
-            this.fetchClientWellKnown();
+            void this.fetchClientWellKnown();
         }
 
         this.toDeviceMessageQueue.start();
         this.serverCapabilitiesService.start();
+        if (this._unstable_shouldApplyMessageRetention) {
+            this.retentionPolicyService?.start();
+        }
     }
 
     /**
@@ -1908,7 +1917,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public retryImmediately(): boolean {
         // don't await for this promise: we just want to kick it off
-        this.toDeviceMessageQueue.sendQueue();
+        void this.toDeviceMessageQueue.sendQueue();
         return this.syncApi?.retryImmediately() ?? false;
     }
 
@@ -1936,9 +1945,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise resolving with The capabilities of the homeserver
      */
     public async getCapabilities(): Promise<Capabilities> {
-        const caps = this.serverCapabilitiesService.getCachedCapabilities();
+        const caps = this.serverCapabilitiesService.getCached();
         if (caps) return caps;
-        return this.serverCapabilitiesService.fetchCapabilities();
+        return this.serverCapabilitiesService.fetch();
     }
 
     /**
@@ -1948,7 +1957,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns The capabilities of the homeserver
      */
     public getCachedCapabilities(): Capabilities | undefined {
-        return this.serverCapabilitiesService.getCachedCapabilities();
+        return this.serverCapabilitiesService.getCached();
     }
 
     /**
@@ -1958,7 +1967,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns A promise which resolves to the capabilities of the homeserver
      */
     public fetchCapabilities(): Promise<Capabilities> {
-        return this.serverCapabilitiesService.fetchCapabilities();
+        return this.serverCapabilitiesService.fetch();
     }
 
     /**
@@ -2042,7 +2051,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));
         this.on(RoomStateEvent.Events, rustCrypto.onRoomStateEvent.bind(rustCrypto));
         this.on(ClientEvent.Event, (event) => {
-            rustCrypto.onLiveEventFromSync(event);
+            void rustCrypto.onLiveEventFromSync(event);
         });
 
         // re-emit the events emitted by the crypto impl
@@ -2500,7 +2509,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public resendEvent(event: MatrixEvent, room: Room): Promise<ISendEventResponse> {
         // also kick the to-device queue to retry
-        this.toDeviceMessageQueue.sendQueue();
+        void this.toDeviceMessageQueue.sendQueue();
 
         this.updatePendingEventStatus(room, event, EventStatus.SENDING);
         return this.encryptAndSendEvent(room, event);
@@ -3742,7 +3751,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 $delayId: delayId,
                 $action: action,
             });
-            return await this.http.request(Method.Post, path, undefined, undefined, {
+            // Although this endpoint supports being used without authentication,
+            // do authenticate here to make ratelimiting apply per user instead of per source IP address,
+            // if the server supports that
+            return await this.http.authedRequest(Method.Post, path, undefined, undefined, {
                 ...requestOptions,
                 prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
             });
@@ -5901,7 +5913,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (this.isInitialSyncComplete()) {
             if (supportsMatrixCall()) {
                 this.callEventHandler!.start();
-                this.groupCallEventHandler!.start();
+                void this.groupCallEventHandler!.start();
             }
 
             this.off(ClientEvent.Sync, this.startCallEventHandler);
@@ -6415,7 +6427,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         if (event.shouldAttemptDecryption() && this.getCrypto()) {
-            event.attemptDecryption(this.cryptoBackend!, options);
+            void event.attemptDecryption(this.cryptoBackend!, options);
         }
 
         if (event.isBeingDecrypted()) {
@@ -8819,8 +8831,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (!events?.length) return;
         if (!room) return;
 
-        room.currentState.processBeaconEvents(events, this);
-        room.processPollEvents(events);
+        void room.currentState.processBeaconEvents(events, this);
+        void room.processPollEvents(events);
     }
 
     /**

package/node_modules/matrix-js-sdk/src/crypto-api/index.ts

@@ -74,8 +74,6 @@ export interface StartDehydrationOpts {
 
 /**
  * Public interface to the cryptography parts of the js-sdk
- *
- * @remarks Currently, this is a work-in-progress. In time, more methods will be added here.
  */
 export interface CryptoApi {
     /**
@@ -267,10 +265,18 @@ export interface CryptoApi {
      *
      * This is useful if the user was previously verified but is not anymore
      * ({@link UserVerificationStatus.wasCrossSigningVerified}) and it is not possible to verify him again now.
-     *
      */
     withdrawVerificationRequirement(userId: string): Promise<void>;
 
+    /**
+     * Get the given user's public cross-signing keys, if they have published any, and we have fetched them to
+     * our store.
+     *
+     * Normally this is only useful to applications as debug info, since the SDK handles keeping track of a
+     * user's identity, and whether their devices are verified.
+     */
+    getUserCrossSigningKeys(userId: string): Promise<Partial<CrossSigningKeys> | null>;
+
     /**
      * Get the verification status of a given device.
      *
@@ -1224,11 +1230,16 @@ export interface CreateSecretStorageOpts {
 
 /** Types of cross-signing key */
 export enum CrossSigningKey {
-    Master = "master",
-    SelfSigning = "self_signing",
-    UserSigning = "user_signing",
+    Master = "master_key",
+    SelfSigning = "self_signing_key",
+    UserSigning = "user_signing_key",
 }
 
+/** All of a user's cross-signing keys.
+ * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload
+ */
+export type CrossSigningKeys = Record<CrossSigningKey, CrossSigningKeyInfo>;
+
 /**
  * Information on one of the cross-signing keys.
  * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload

package/node_modules/matrix-js-sdk/src/embedded.ts

@@ -527,19 +527,17 @@ export class RoomWidgetClient extends MatrixClient {
             );
         }
 
-        let updateDelayedEvent: (delayId: string) => Promise<unknown>;
         switch (action) {
             case UpdateDelayedEventAction.Cancel:
-                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                await this.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
             case UpdateDelayedEventAction.Restart:
-                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                await this.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
             case UpdateDelayedEventAction.Send:
-                updateDelayedEvent = this.widgetApi.sendScheduledDelayedEvent;
+                await this.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
         }
-        await updateDelayedEvent.call(this.widgetApi, delayId).catch(timeoutToConnectionError);
         return {};
     }
 
@@ -682,7 +680,7 @@ export class RoomWidgetClient extends MatrixClient {
     }
 
     private async ack(ev: CustomEvent<IWidgetApiRequest>): Promise<void> {
-        await this.widgetApi.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});
+        this.widgetApi.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});
     }
 
     private updateTxId = async (event: MatrixEvent): Promise<void> => {

package/node_modules/matrix-js-sdk/src/filter-component.ts

@@ -195,6 +195,7 @@ export class FilterComponent {
      * @returns events which matched the filter component
      */
     public filter(events: MatrixEvent[]): MatrixEvent[] {
+        // oxlint-disable-next-line typescript/unbound-method
         return events.filter(this.check, this);
     }
 

package/node_modules/matrix-js-sdk/src/http-api/utils.ts

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { parse as parseContentType, type ParsedMediaType } from "content-type";
+import { parse as parseContentType, type ContentType } from "content-type";
 
 import { logger } from "../logger.ts";
 import { sleep } from "../utils.ts";
@@ -39,7 +39,7 @@ export function timeoutSignal(ms: number): AbortSignal {
 
 export function anySignal(signals: AbortSignal[]): {
     signal: AbortSignal;
-    cleanup(): void;
+    cleanup(this: void): void;
 } {
     const controller = new AbortController();
 
@@ -92,7 +92,7 @@ export function parseErrorResponse(response: XMLHttpRequest | Response, body?: s
           )
         : response.headers;
 
-    let contentType: ParsedMediaType | null;
+    let contentType: ContentType | null;
     try {
         contentType = getResponseContentType(httpHeaders);
     } catch (e) {
@@ -136,15 +136,10 @@ function isXhr(response: XMLHttpRequest | Response): response is XMLHttpRequest
  * @param response - response object
  * @returns parsed content-type header, or null if not found
  */
-function getResponseContentType(headers: Headers): ParsedMediaType | null {
+function getResponseContentType(headers: Headers): ContentType | null {
     const contentType = headers.get("Content-Type");
     if (contentType === null) return null;
-
-    try {
-        return parseContentType(contentType);
-    } catch (e) {
-        throw new Error(`Error parsing Content-Type '${contentType}': ${e}`);
-    }
+    return parseContentType(contentType);
 }
 
 /**

package/node_modules/matrix-js-sdk/src/interactive-auth.ts

@@ -205,7 +205,7 @@ interface IOpts<T> {
      * The busyChanged callback should be used instead of the background flag.
      * Should return a promise which resolves to the successful response or rejects with a MatrixError.
      */
-    doRequest(auth: AuthDict | null, background: boolean): Promise<T>;
+    doRequest(this: void, auth: AuthDict | null, background: boolean): Promise<T>;
     /**
      * Called when the status of the UI auth changes,
      * ie. when the state of an auth stage changes of when the auth flow moves to a new stage.
@@ -219,7 +219,7 @@ interface IOpts<T> {
      *     m.login.email.identity:
      *         * emailSid: string, the sid of the active email auth session
      */
-    stateUpdated(nextStage: AuthType | string, status: IStageStatus): void;
+    stateUpdated(this: void, nextStage: AuthType | string, status: IStageStatus): void;
 
     /**
      * A function that takes the email address (string), clientSecret (string), attempt number (int) and
@@ -227,14 +227,20 @@ interface IOpts<T> {
      * function.
      * If the resulting promise rejects, the rejection will propagate through to the attemptAuth promise.
      */
-    requestEmailToken(email: string, secret: string, attempt: number, session: string): Promise<{ sid: string }>;
+    requestEmailToken(
+        this: void,
+        email: string,
+        secret: string,
+        attempt: number,
+        session: string,
+    ): Promise<{ sid: string }>;
     /**
      * Called whenever the interactive auth logic becomes busy submitting information provided by the user or finishes.
      * After this has been called with true the UI should indicate that a request is in progress
      * until it is called again with false.
      */
-    busyChanged?(busy: boolean): void;
-    startAuthStage?(nextStage: string): Promise<void>; // LEGACY
+    busyChanged?(this: void, busy: boolean): void;
+    startAuthStage?(this: void, nextStage: string): Promise<void>; // LEGACY
 }
 
 /**

package/node_modules/matrix-js-sdk/src/matrix.ts

@@ -71,6 +71,7 @@ export * from "./@types/location.ts";
 export * from "./@types/threepids.ts";
 export * from "./@types/auth.ts";
 export * from "./@types/polls.ts";
+export * from "./@types/retention.ts";
 export type * from "./@types/local_notifications.ts";
 export type * from "./@types/registration.ts";
 export * from "./@types/read_receipts.ts";

package/node_modules/matrix-js-sdk/src/matrixrtc/LivekitTransport.ts

@@ -32,7 +32,7 @@ export const isLivekitTransport = (object: any): object is LivekitTransport =>
     isLivekitTransportConfig(object) && "livekit_alias" in object;
 
 /**
- * @deprecated, this is just needed for the old focus active / focus fields of a call membership.
+ * @deprecated this is just needed for the old focus active / focus fields of a call membership.
  * Not needed for new implementations.
  */
 export interface LivekitFocusSelection extends Transport {

package/node_modules/matrix-js-sdk/src/matrixrtc/MatrixRTCSession.ts

@@ -755,9 +755,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
         this.membershipNeedsRecalculation = true;
         // Chain the recalculation.
-        this.recalculateSessionMembersPromise = this.recalculateSessionMembersPromise
-            .finally()
-            .then(() => this.recalculateSessionMembers());
+        this.recalculateSessionMembersPromise = this.recalculateSessionMembersPromise.then(
+            () => this.recalculateSessionMembers(),
+            () => this.recalculateSessionMembers(),
+        );
         return this.recalculateSessionMembersPromise;
     }
 
@@ -815,7 +816,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
         // This also needs to be done if `changed` = false
         // A member might have updated their fingerprint (created_ts)
-        void this.encryptionManager?.onMembershipsUpdate(oldMemberships);
+        this.encryptionManager?.onMembershipsUpdate(oldMemberships);
 
         this.setExpiryTimer();
     };

package/node_modules/matrix-js-sdk/src/matrixrtc/MembershipManager.ts

@@ -207,6 +207,8 @@ export class MembershipManager
      * transport selection will be used instead.
      * @param onError This will be called once the membership manager encounters an unrecoverable error.
      * This should bubble up the the frontend to communicate that the call does not work in the current environment.
+     * The original underlying error is preserved as `error.cause`, so consumers can `instanceof`-check the typed
+     * cause.
      */
     public join(fociPreferred: Transport[], multiSfuFocus?: Transport, onError?: (error: unknown) => void): void {
         if (this.scheduler.running) {

package/node_modules/matrix-js-sdk/src/matrixrtc/MembershipManagerActionScheduler.ts

@@ -103,7 +103,10 @@ export class ActionScheduler {
                         // `this.wakeup` can also be called and sets the `wakeupUpdate` object while we are in the handler.
                         handlerResult = await this.membershipLoopHandler(nextAction.type as MembershipActionType);
                     } catch (e) {
-                        throw Error(`The MembershipManager shut down because of the end condition: ${e}`);
+                        // Preserve the original error as `cause`.
+                        throw new Error(`The MembershipManager shut down because of the end condition: ${e}`, {
+                            cause: e,
+                        });
                     }
                 }
                 // remove the processed action only after we are done processing

package/node_modules/matrix-js-sdk/src/models/MSC3089Branch.ts

@@ -198,7 +198,7 @@ export class MSC3089Branch {
         additionalContent?: IContent,
     ): Promise<ISendEventResponse> {
         const fileEventResponse = await this.directory.createFile(name, encryptedContents, info, {
-            ...(additionalContent ?? {}),
+            ...additionalContent,
             "m.new_content": true,
             "m.relates_to": {
                 rel_type: RelationType.Replace,