diff --git a/spec/unit/embedded.spec.ts b/spec/unit/embedded.spec.ts
index 7f0ce949faf..ff48996cfbb 100644
--- a/spec/unit/embedded.spec.ts
+++ b/spec/unit/embedded.spec.ts
@@ -414,13 +414,9 @@ describe("RoomWidgetClient", () => {
             it("sends delayed message events", async () => {
                 await makeClient({ sendDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
                 expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
-                await client._unstable_sendDelayedEvent(
-                    "!1:example.org",
-                    { delay: 2000 },
-                    null,
-                    "org.matrix.rageshake_request",
-                    { request_id: 123 },
-                );
+                await client._unstable_sendDelayedEvent("!1:example.org", 2000, null, "org.matrix.rageshake_request", {
+                    request_id: 123,
+                });
                 expect(widgetApi.sendRoomEvent).toHaveBeenCalledWith(
                     "org.matrix.rageshake_request",
                     { request_id: 123 },
@@ -430,26 +426,6 @@ describe("RoomWidgetClient", () => {
                 );
             });
 
-            it("sends child action delayed message events", async () => {
-                await makeClient({ sendDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
-                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
-                const parentDelayId = `id-${Math.random()}`;
-                await client._unstable_sendDelayedEvent(
-                    "!1:example.org",
-                    { parent_delay_id: parentDelayId },
-                    null,
-                    "org.matrix.rageshake_request",
-                    { request_id: 123 },
-                );
-                expect(widgetApi.sendRoomEvent).toHaveBeenCalledWith(
-                    "org.matrix.rageshake_request",
-                    { request_id: 123 },
-                    "!1:example.org",
-                    undefined,
-                    parentDelayId,
-                );
-            });
-
             it("sends delayed state events", async () => {
                 await makeClient({
                     sendDelayedEvents: true,
@@ -457,32 +433,8 @@ describe("RoomWidgetClient", () => {
                 });
                 expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
                 await client._unstable_sendDelayedStateEvent(
-                    "!1:example.org",
-                    { delay: 2000 },
-                    "org.example.foo",
-                    { hello: "world" },
-                    "bar",
-                );
-                expect(widgetApi.sendStateEvent).toHaveBeenCalledWith(
-                    "org.example.foo",
-                    "bar",
-                    { hello: "world" },
                     "!1:example.org",
                     2000,
-                    undefined,
-                );
-            });
-
-            it("sends child action delayed state events", async () => {
-                await makeClient({
-                    sendDelayedEvents: true,
-                    sendState: [{ eventType: "org.example.foo", stateKey: "bar" }],
-                });
-                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
-                const parentDelayId = `fg-${Math.random()}`;
-                await client._unstable_sendDelayedStateEvent(
-                    "!1:example.org",
-                    { parent_delay_id: parentDelayId },
                     "org.example.foo",
                     { hello: "world" },
                     "bar",
@@ -492,8 +444,8 @@ describe("RoomWidgetClient", () => {
                     "bar",
                     { hello: "world" },
                     "!1:example.org",
+                    2000,
                     undefined,
-                    parentDelayId,
                 );
             });
 
@@ -504,13 +456,9 @@ describe("RoomWidgetClient", () => {
                     event_id: `$${Math.random()}`,
                 });
                 await expect(
-                    client._unstable_sendDelayedEvent(
-                        "!1:example.org",
-                        { delay: 2000 },
-                        null,
-                        "org.matrix.rageshake_request",
-                        { request_id: 123 },
-                    ),
+                    client._unstable_sendDelayedEvent("!1:example.org", 2000, null, "org.matrix.rageshake_request", {
+                        request_id: 123,
+                    }),
                 ).rejects.toThrow();
             });
 
@@ -526,7 +474,7 @@ describe("RoomWidgetClient", () => {
                 await expect(
                     client._unstable_sendDelayedStateEvent(
                         "!1:example.org",
-                        { delay: 2000 },
+                        2000,
                         "org.example.foo",
                         { hello: "world" },
                         "bar",
@@ -584,13 +532,9 @@ describe("RoomWidgetClient", () => {
             it("fails to send delayed message events", async () => {
                 await makeClient({ sendEvent: ["org.matrix.rageshake_request"] });
                 await expect(
-                    client._unstable_sendDelayedEvent(
-                        "!1:example.org",
-                        { delay: 2000 },
-                        null,
-                        "org.matrix.rageshake_request",
-                        { request_id: 123 },
-                    ),
+                    client._unstable_sendDelayedEvent("!1:example.org", 2000, null, "org.matrix.rageshake_request", {
+                        request_id: 123,
+                    }),
                 ).rejects.toThrow("Server does not support");
             });
 
@@ -599,7 +543,7 @@ describe("RoomWidgetClient", () => {
                 await expect(
                     client._unstable_sendDelayedStateEvent(
                         "!1:example.org",
-                        { delay: 2000 },
+                        2000,
                         "org.example.foo",
                         { hello: "world" },
                         "bar",
diff --git a/spec/unit/matrix-client.spec.ts b/spec/unit/matrix-client.spec.ts
index 73d4c7ecdd4..9a01411e053 100644
--- a/spec/unit/matrix-client.spec.ts
+++ b/spec/unit/matrix-client.spec.ts
@@ -774,7 +774,7 @@ describe("MatrixClient", function () {
         const roomId = "!room:example.org";
         const body = "This is the body";
         const content = { body, msgtype: MsgType.Text } satisfies RoomMessageEventContent;
-        const timeoutDelayOpts = { delay: 2000 };
+        const DELAYED_EVENT_DELAY = 2000;
         const realTimeoutDelayOpts = { "org.matrix.msc4140.delay": 2000 };
 
         beforeEach(() => {
@@ -788,7 +788,7 @@ describe("MatrixClient", function () {
             await expect(
                 client._unstable_sendDelayedEvent(
                     roomId,
-                    timeoutDelayOpts,
+                    DELAYED_EVENT_DELAY,
                     null,
                     EventType.RoomMessage,
                     { ...content },
@@ -797,7 +797,7 @@ describe("MatrixClient", function () {
             ).rejects.toThrow(errorMessage);
 
             await expect(
-                client._unstable_sendDelayedStateEvent(roomId, timeoutDelayOpts, EventType.RoomTopic, {
+                client._unstable_sendDelayedStateEvent(roomId, DELAYED_EVENT_DELAY, EventType.RoomTopic, {
                     topic: "topic",
                 }),
             ).rejects.toThrow(errorMessage);
@@ -825,32 +825,15 @@ describe("MatrixClient", function () {
                 expectBody: content,
             });
 
-            const { delay_id: timeoutDelayId } = await client._unstable_sendDelayedEvent(
-                roomId,
-                timeoutDelayOpts,
-                null,
-                EventType.RoomMessage,
-                { ...content },
-                timeoutDelayTxnId,
-            );
-
-            const actionDelayTxnId = client.makeTxnId();
-            httpLookups.push({
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${actionDelayTxnId}`,
-                expectQueryParams: { "org.matrix.msc4140.parent_delay_id": timeoutDelayId },
-                data: { delay_id: "id2" },
-                expectBody: content,
-            });
-
             await client._unstable_sendDelayedEvent(
                 roomId,
-                { parent_delay_id: timeoutDelayId },
+                DELAYED_EVENT_DELAY,
                 null,
                 EventType.RoomMessage,
                 { ...content },
-                actionDelayTxnId,
+                timeoutDelayTxnId,
             );
+            // expect not to throw
         });
 
         it("works with non-null threadId", async () => {
@@ -874,31 +857,13 @@ describe("MatrixClient", function () {
                 expectBody,
             });
 
-            const { delay_id: timeoutDelayId } = await client._unstable_sendDelayedEvent(
-                roomId,
-                timeoutDelayOpts,
-                threadId,
-                EventType.RoomMessage,
-                { ...content },
-                timeoutDelayTxnId,
-            );
-
-            const actionDelayTxnId = client.makeTxnId();
-            httpLookups.push({
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${actionDelayTxnId}`,
-                expectQueryParams: { "org.matrix.msc4140.parent_delay_id": timeoutDelayId },
-                data: { delay_id: "id2" },
-                expectBody,
-            });
-
             await client._unstable_sendDelayedEvent(
                 roomId,
-                { parent_delay_id: timeoutDelayId },
+                DELAYED_EVENT_DELAY,
                 threadId,
                 EventType.RoomMessage,
                 { ...content },
-                actionDelayTxnId,
+                timeoutDelayTxnId,
             );
         });
 
@@ -932,31 +897,13 @@ describe("MatrixClient", function () {
                 expectBody,
             });
 
-            const { delay_id: timeoutDelayId } = await client._unstable_sendDelayedEvent(
-                roomId,
-                timeoutDelayOpts,
-                threadId,
-                EventType.RoomMessage,
-                { ...content },
-                timeoutDelayTxnId,
-            );
-
-            const actionDelayTxnId = client.makeTxnId();
-            httpLookups.push({
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${actionDelayTxnId}`,
-                expectQueryParams: { "org.matrix.msc4140.parent_delay_id": timeoutDelayId },
-                data: { delay_id: "id2" },
-                expectBody,
-            });
-
             await client._unstable_sendDelayedEvent(
                 roomId,
-                { parent_delay_id: timeoutDelayId },
+                DELAYED_EVENT_DELAY,
                 threadId,
                 EventType.RoomMessage,
                 { ...content },
-                actionDelayTxnId,
+                timeoutDelayTxnId,
             );
         });
 
@@ -1000,31 +947,13 @@ describe("MatrixClient", function () {
                 expectBody,
             });
 
-            const { delay_id: timeoutDelayId } = await client._unstable_sendDelayedEvent(
-                roomId,
-                timeoutDelayOpts,
-                threadId,
-                EventType.RoomMessage,
-                { ...content },
-                timeoutDelayTxnId,
-            );
-
-            const actionDelayTxnId = client.makeTxnId();
-            httpLookups.push({
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${actionDelayTxnId}`,
-                expectQueryParams: { "org.matrix.msc4140.parent_delay_id": timeoutDelayId },
-                data: { delay_id: "id2" },
-                expectBody,
-            });
-
             await client._unstable_sendDelayedEvent(
                 roomId,
-                { parent_delay_id: timeoutDelayId },
+                DELAYED_EVENT_DELAY,
                 threadId,
                 EventType.RoomMessage,
                 { ...content },
-                actionDelayTxnId,
+                timeoutDelayTxnId,
             );
         });
 
@@ -1040,27 +969,9 @@ describe("MatrixClient", function () {
                 expectBody: content,
             });
 
-            const { delay_id: timeoutDelayId } = await client._unstable_sendDelayedStateEvent(
-                roomId,
-                timeoutDelayOpts,
-                EventType.RoomTopic,
-                { ...content },
-            );
-
-            httpLookups.push({
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/state/m.room.topic/`,
-                expectQueryParams: { "org.matrix.msc4140.parent_delay_id": timeoutDelayId },
-                data: { delay_id: "id2" },
-                expectBody: content,
+            await client._unstable_sendDelayedStateEvent(roomId, DELAYED_EVENT_DELAY, EventType.RoomTopic, {
+                ...content,
             });
-
-            await client._unstable_sendDelayedStateEvent(
-                roomId,
-                { parent_delay_id: timeoutDelayId },
-                EventType.RoomTopic,
-                { ...content },
-            );
         });
 
         describe("lookups", () => {
@@ -3086,7 +2997,9 @@ describe("MatrixClient", function () {
             const client = await setUpClient(versionsResponse);
 
             const url = new URL(
-                `/_matrix/client/unstable/org.matrix.msc3391/user/${encodeURIComponent(userId)}/account_data/${eventType}`,
+                `/_matrix/client/unstable/org.matrix.msc3391/user/${encodeURIComponent(
+                    userId,
+                )}/account_data/${eventType}`,
                 TEST_HOMESERVER_URL,
             ).toString();
             fetchMock.delete(url, {});
diff --git a/src/@types/requests.ts b/src/@types/requests.ts
index ff2072915d6..c06695e5d36 100644
--- a/src/@types/requests.ts
+++ b/src/@types/requests.ts
@@ -97,23 +97,19 @@ export interface ISendEventResponse {
     event_id: string;
 }
 
-export type SendDelayedEventRequestOpts = { parent_delay_id: string } | { delay: number; parent_delay_id?: string };
-
-export function isSendDelayedEventRequestOpts(opts: object): opts is SendDelayedEventRequestOpts {
-    if ("parent_delay_id" in opts && typeof opts.parent_delay_id !== "string") {
-        // Invalid type, reject
-        return false;
-    }
-    if ("delay" in opts && typeof opts.delay !== "number") {
-        // Invalid type, reject.
-        return true;
-    }
-    // At least one of these fields must be specified.
-    return "delay" in opts || "parent_delay_id" in opts;
+// sticky
+export interface SendStickyEventRequestOpts {
+    sticky_duration_ms: number;
 }
-export type SendDelayedEventResponse = {
+
+// delayed
+export interface SendDelayedEventRequestOpts {
+    delay: number;
+}
+
+export interface SendDelayedEventResponse {
     delay_id: string;
-};
+}
 
 export enum UpdateDelayedEventAction {
     Cancel = "cancel",
diff --git a/src/client.ts b/src/client.ts
index e6756f9ac18..7fee2a6b3c1 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -103,7 +103,7 @@ import {
 import { RoomMemberEvent, type RoomMemberEventHandlerMap } from "./models/room-member.ts";
 import { type IPowerLevelsContent, type RoomStateEvent, type RoomStateEventHandlerMap } from "./models/room-state.ts";
 import {
-    isSendDelayedEventRequestOpts,
+    type SendStickyEventRequestOpts,
     UpdateDelayedEventAction,
     type DelayedEventInfo,
     type IAddThreePidOnlyBody,
@@ -2006,7 +2006,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             deviceId: deviceId,
             secretStorage: this.secretStorage,
             cryptoCallbacks: this.cryptoCallbacks,
-            storePrefix: args.useIndexedDB === false ? null : (args.cryptoDatabasePrefix ?? RUST_SDK_STORE_PREFIX),
+            storePrefix: args.useIndexedDB === false ? null : args.cryptoDatabasePrefix ?? RUST_SDK_STORE_PREFIX,
             storeKey: args.storageKey,
             storePassphrase: args.storagePassword,
 
@@ -2393,10 +2393,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // If we were invited to the room, the ID of the user that sent the invite. Otherwise, `null`.
         const inviter =
-            preJoinMembership == KnownMembership.Invite ? (roomMember?.events.member?.getSender() ?? null) : null;
+            preJoinMembership == KnownMembership.Invite ? roomMember?.events.member?.getSender() ?? null : null;
 
         this.logger.debug(
-            `joinRoom[${roomIdOrAlias}]: preJoinMembership=${preJoinMembership}, inviter=${inviter}, opts=${JSON.stringify(opts)}`,
+            `joinRoom[${roomIdOrAlias}]: preJoinMembership=${preJoinMembership}, inviter=${inviter}, opts=${JSON.stringify(
+                opts,
+            )}`,
         );
         if (preJoinMembership == KnownMembership.Join) return room!;
 
@@ -2758,54 +2760,51 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
     }
 
-    /**
-     * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
-     * @param txnId - Optional.
-     * @returns Promise which resolves: to an empty object `{}`
-     * @returns Rejects: with an error response.
-     */
     private sendCompleteEvent(params: {
         roomId: string;
         threadId: string | null;
         eventObject: Partial<IEvent>;
-        queryDict?: QueryDict;
+        queryDict: SendDelayedEventRequestOpts;
+        txnId?: string;
+    }): Promise<SendDelayedEventResponse>;
+    private sendCompleteEvent(params: {
+        roomId: string;
+        threadId: string | null;
+        eventObject: Partial<IEvent>;
+        queryDict: QueryDict & SendDelayedEventRequestOpts;
+        txnId?: string;
+    }): Promise<SendDelayedEventResponse>;
+    private sendCompleteEvent(params: {
+        roomId: string;
+        threadId: string | null;
+        eventObject: Partial<IEvent>;
+        queryDict?: QueryDict | SendStickyEventRequestOpts;
         txnId?: string;
     }): Promise<ISendEventResponse>;
     /**
-     * Sends a delayed event (MSC4140).
      * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
-     * @param delayOpts - Properties of the delay for this event.
      * @param txnId - Optional.
      * @returns Promise which resolves: to an empty object `{}`
      * @returns Rejects: with an error response.
      */
-    private sendCompleteEvent(params: {
-        roomId: string;
-        threadId: string | null;
-        eventObject: Partial<IEvent>;
-        delayOpts: SendDelayedEventRequestOpts;
-        queryDict?: QueryDict;
-        txnId?: string;
-    }): Promise<SendDelayedEventResponse>;
     private sendCompleteEvent({
         roomId,
         threadId,
         eventObject,
-        delayOpts,
         queryDict,
         txnId,
     }: {
         roomId: string;
         threadId: string | null;
         eventObject: Partial<IEvent>;
-        delayOpts?: SendDelayedEventRequestOpts;
-        queryDict?: QueryDict;
+        queryDict?: QueryDict | SendDelayedEventRequestOpts | SendStickyEventRequestOpts;
         txnId?: string;
     }): Promise<SendDelayedEventResponse | ISendEventResponse> {
         if (!txnId) {
             txnId = this.makeTxnId();
         }
 
+        const isDalayedEvent = queryDict && "delay" in queryDict && typeof queryDict.delay === "number";
         // We always construct a MatrixEvent when sending because the store and scheduler use them.
         // We'll extract the params back out if it turns out the client has no scheduler or store.
         const localEvent = new MatrixEvent(
@@ -2824,7 +2823,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             localEvent.setThread(thread);
         }
 
-        if (!delayOpts) {
+        if (!isDalayedEvent) {
             // set up re-emitter for this new event - this is normally the job of EventMapper but we don't use it here
             this.reEmitter.reEmit(localEvent, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);
             room?.reEmitter.reEmit(localEvent, [MatrixEventEvent.BeforeRedaction]);
@@ -2844,14 +2843,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         const type = localEvent.getType();
         this.logger.debug(
-            `sendEvent of type ${type} in ${roomId} with txnId ${txnId}${delayOpts ? " (delayed event)" : ""}${queryDict ? " query params: " + JSON.stringify(queryDict) : ""}`,
+            `sendEvent of type ${type} in ${roomId} with txnId ${txnId}${isDalayedEvent ? " (delayed event)" : ""}${
+                queryDict ? " query params: " + JSON.stringify(queryDict) : ""
+            }`,
         );
 
         localEvent.setTxnId(txnId);
         localEvent.setStatus(EventStatus.SENDING);
 
         // TODO: separate store for delayed events?
-        if (!delayOpts) {
+        if (!isDalayedEvent) {
             // add this event immediately to the local store as 'sending'.
             room?.addPendingEvent(localEvent, txnId);
 
@@ -2861,22 +2862,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             if (localEvent.status === EventStatus.NOT_SENT) {
                 return Promise.reject(new Error("Event blocked by other events not yet sent"));
             }
-
-            return this.encryptAndSendEvent(room, localEvent, queryDict);
-        } else {
-            return this.encryptAndSendEvent(room, localEvent, delayOpts, queryDict);
         }
+        return this.encryptAndSendEvent(room, localEvent, queryDict);
     }
 
     /**
      * encrypts the event if necessary; adds the event to the queue, or sends it; marks the event as sent/unsent
      * @returns returns a promise which resolves with the result of the send request
      */
-    protected async encryptAndSendEvent(
-        room: Room | null,
-        event: MatrixEvent,
-        queryDict?: QueryDict,
-    ): Promise<ISendEventResponse>;
     /**
      * Simply sends a delayed event without encrypting it.
      * TODO: Allow encrypted delayed events, and encrypt them properly
@@ -2886,20 +2879,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     protected async encryptAndSendEvent(
         room: Room | null,
         event: MatrixEvent,
-        delayOpts: SendDelayedEventRequestOpts,
-        queryDict?: QueryDict,
+        queryDict: (QueryDict | SendStickyEventRequestOpts) & SendDelayedEventRequestOpts,
+    ): Promise<SendDelayedEventResponse>;
+    protected async encryptAndSendEvent(
+        room: Room | null,
+        event: MatrixEvent,
+        queryDict?: QueryDict | SendStickyEventRequestOpts | SendDelayedEventRequestOpts,
     ): Promise<ISendEventResponse>;
     protected async encryptAndSendEvent(
         room: Room | null,
         event: MatrixEvent,
-        delayOptsOrQuery?: SendDelayedEventRequestOpts | QueryDict,
-        queryDict?: QueryDict,
+        queryDict?: QueryDict | SendStickyEventRequestOpts | SendDelayedEventRequestOpts,
     ): Promise<ISendEventResponse | SendDelayedEventResponse> {
-        let queryOpts = queryDict;
-        if (delayOptsOrQuery && isSendDelayedEventRequestOpts(delayOptsOrQuery)) {
-            return this.sendEventHttpRequest(event, delayOptsOrQuery, queryOpts);
-        } else if (!queryOpts) {
-            queryOpts = delayOptsOrQuery;
+        if (queryDict && "delay" in queryDict && queryDict.delay !== undefined) {
+            return this.sendEventHttpRequest(event, queryDict);
         }
         try {
             let cancelled: boolean;
@@ -2936,7 +2929,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             }
 
             if (!promise) {
-                promise = this.sendEventHttpRequest(event, queryOpts);
+                promise = this.sendEventHttpRequest(event, queryDict);
                 if (room) {
                     promise = promise.then((res) => {
                         room.updatePendingEvent(event, EventStatus.SENT, res["event_id"]);
@@ -3051,16 +3044,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
     }
 
-    private sendEventHttpRequest(event: MatrixEvent, queryDict?: QueryDict): Promise<ISendEventResponse>;
     private sendEventHttpRequest(
         event: MatrixEvent,
-        delayOpts: SendDelayedEventRequestOpts,
-        queryDict?: QueryDict,
+        queryDict: (QueryDict | SendStickyEventRequestOpts) & SendDelayedEventRequestOpts,
     ): Promise<SendDelayedEventResponse>;
     private sendEventHttpRequest(
         event: MatrixEvent,
-        queryOrDelayOpts?: SendDelayedEventRequestOpts | QueryDict,
-        queryDict?: QueryDict,
+        queryDict?: QueryDict | SendStickyEventRequestOpts | SendDelayedEventRequestOpts,
+    ): Promise<ISendEventResponse>;
+    private sendEventHttpRequest(
+        event: MatrixEvent,
+        queryDict?: QueryDict | SendStickyEventRequestOpts | SendDelayedEventRequestOpts,
     ): Promise<ISendEventResponse | SendDelayedEventResponse> {
         let txnId = event.getTxnId();
         if (!txnId) {
@@ -3093,19 +3087,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             path = utils.encodeUri("/rooms/$roomId/send/$eventType/$txnId", pathParams);
         }
 
-        const delayOpts =
-            queryOrDelayOpts && isSendDelayedEventRequestOpts(queryOrDelayOpts) ? queryOrDelayOpts : undefined;
-        const queryOpts = !delayOpts ? queryOrDelayOpts : queryDict;
+        const isDelayedEvent = queryDict && "delay" in queryDict && typeof queryDict.delay === "number";
+
+        let query = queryDict;
+        if (query) {
+            query = replaceParam("delay", `${UNSTABLE_MSC4140_DELAYED_EVENTS}.delay`, query);
+            query = replaceParam("sticky_duration_ms", `${UNSTABLE_MSC4354_STICKY_EVENTS}.sticky_duration_ms`, query);
+        }
+
         const content = event.getWireContent();
-        if (delayOpts) {
-            return this.http.authedRequest<SendDelayedEventResponse>(
-                Method.Put,
-                path,
-                { ...getUnstableDelayQueryOpts(delayOpts), ...queryOpts },
-                content,
-            );
+
+        if (isDelayedEvent) {
+            return this.http.authedRequest<SendDelayedEventResponse>(Method.Put, path, query, content);
         } else {
-            return this.http.authedRequest<ISendEventResponse>(Method.Put, path, queryOpts, content).then((res) => {
+            return this.http.authedRequest<ISendEventResponse>(Method.Put, path, query, content).then((res) => {
                 this.logger.debug(`Event sent to ${event.getRoomId()} with event id ${res.event_id}`);
                 return res;
             });
@@ -3464,7 +3459,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     // eslint-disable-next-line
     public async _unstable_sendDelayedEvent<K extends keyof TimelineEvents>(
         roomId: string,
-        delayOpts: SendDelayedEventRequestOpts,
+        delay: number,
         threadId: string | null,
         eventType: K,
         content: TimelineEvents[K],
@@ -3482,7 +3477,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             roomId,
             threadId,
             eventObject: { type: eventType, content },
-            delayOpts,
+            queryDict: { delay },
             txnId,
         });
     }
@@ -3500,7 +3495,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public async _unstable_sendStickyDelayedEvent<K extends keyof TimelineEvents>(
         roomId: string,
         stickDuration: number,
-        delayOpts: SendDelayedEventRequestOpts,
+        delay: number,
         threadId: string | null,
         eventType: K,
         content: TimelineEvents[K] & { msc4354_sticky_key?: string },
@@ -3524,8 +3519,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             roomId,
             threadId,
             eventObject: { type: eventType, content },
-            queryDict: { "org.matrix.msc4354.sticky_duration_ms": stickDuration },
-            delayOpts,
+            queryDict: { delay, sticky_duration_ms: stickDuration },
             txnId,
         });
     }
@@ -3541,7 +3535,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     // eslint-disable-next-line
     public async _unstable_sendDelayedStateEvent<K extends keyof StateEvents>(
         roomId: string,
-        delayOpts: SendDelayedEventRequestOpts,
+        delay: number,
         eventType: K,
         content: StateEvents[K],
         stateKey = "",
@@ -3563,7 +3557,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (stateKey !== undefined) {
             path = utils.encodeUri(path + "/$stateKey", pathParams);
         }
-        return this.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content as Body, opts);
+        const queryDict = {
+            [`${UNSTABLE_MSC4140_DELAYED_EVENTS}.delay`]: delay,
+        };
+        return this.http.authedRequest(Method.Put, path, queryDict, content as Body, opts);
     }
 
     /**
@@ -3595,7 +3592,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             roomId,
             threadId,
             eventObject: { type: eventType, content },
-            queryDict: { "org.matrix.msc4354.sticky_duration_ms": stickDuration },
+            queryDict: { sticky_duration_ms: stickDuration },
             txnId,
         });
     }
@@ -8859,12 +8856,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 }
 
-function getUnstableDelayQueryOpts(delayOpts: SendDelayedEventRequestOpts): QueryDict {
-    return Object.fromEntries(
-        Object.entries(delayOpts).map(([k, v]) => [`${UNSTABLE_MSC4140_DELAYED_EVENTS}.${k}`, v]),
-    );
-}
-
 /**
  * recalculates an accurate notifications count on event decryption.
  * Servers do not have enough knowledge about encrypted events to calculate an
diff --git a/src/embedded.ts b/src/embedded.ts
index 6b1fec2b16d..d3bc8d0e1ee 100644
--- a/src/embedded.ts
+++ b/src/embedded.ts
@@ -56,7 +56,7 @@ import { ConnectionError, MatrixError } from "./http-api/errors.ts";
 import { User } from "./models/user.ts";
 import { type Room } from "./models/room.ts";
 import { type ToDeviceBatch, type ToDevicePayload } from "./models/ToDeviceMessage.ts";
-import { MapWithDefault, recursiveMapToObject } from "./utils.ts";
+import { MapWithDefault, type QueryDict, recursiveMapToObject } from "./utils.ts";
 import { type EmptyObject, TypedEventEmitter, UnsupportedDelayedEventsEndpointError } from "./matrix.ts";
 
 interface IStateEventRequest {
@@ -122,6 +122,20 @@ export interface ICapabilities {
      * @defaultValue false
      */
     updateDelayedEvents?: boolean;
+
+    /**
+     * Whether this client needs to be able to send sticky events.
+     * @experimental Part of MSC4354
+     * @defaultValue false
+     */
+    sendSticky?: boolean;
+
+    /**
+     * Whether this client needs to be able to receive sticky events.
+     * @experimental Part of MSC4354
+     * @defaultValue false
+     */
+    receiveSticky?: boolean;
 }
 
 export enum RoomWidgetClientEvent {
@@ -242,6 +256,12 @@ export class RoomWidgetClient extends MatrixClient {
         if (capabilities.updateDelayedEvents) {
             widgetApi.requestCapability(MatrixCapabilities.MSC4157UpdateDelayedEvent);
         }
+        if (capabilities.sendSticky) {
+            widgetApi.requestCapability(MatrixCapabilities.MSC4354SendStickyEvent);
+        }
+        if (capabilities.receiveSticky) {
+            widgetApi.requestCapability(MatrixCapabilities.MSC4354ReceiveStickyEvent);
+        }
         if (capabilities.turnServers) {
             widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);
         }
@@ -346,17 +366,31 @@ export class RoomWidgetClient extends MatrixClient {
         throw new Error(`Unknown room: ${roomIdOrAlias}`);
     }
 
-    protected async encryptAndSendEvent(room: Room, event: MatrixEvent): Promise<ISendEventResponse>;
     protected async encryptAndSendEvent(
         room: Room,
         event: MatrixEvent,
-        delayOpts: SendDelayedEventRequestOpts,
+        queryDict: QueryDict & SendDelayedEventRequestOpts,
     ): Promise<SendDelayedEventResponse>;
     protected async encryptAndSendEvent(
         room: Room,
         event: MatrixEvent,
-        delayOpts?: SendDelayedEventRequestOpts,
+        queryDict?: QueryDict,
+    ): Promise<ISendEventResponse>;
+    protected async encryptAndSendEvent(
+        room: Room,
+        event: MatrixEvent,
+        queryDict?: QueryDict,
     ): Promise<ISendEventResponse | SendDelayedEventResponse> {
+        const delay = queryDict && "delay" in queryDict ? queryDict.delay : undefined;
+        if (delay !== undefined && typeof delay !== "number") {
+            throw new Error("Delay must be a number when defined");
+        }
+        const stickyDurationMs =
+            queryDict && "sticky_duration_ms" in queryDict ? queryDict?.["sticky_duration_ms"] : undefined;
+        if (stickyDurationMs !== undefined && typeof stickyDurationMs !== "number") {
+            throw new Error("Sticky duration must be a number when defined");
+        }
+
         // We need to extend the content with the redacts parameter
         // The js sdk uses event.redacts but the widget api uses event.content.redacts
         // This will be converted back to event.redacts in the widget driver.
@@ -365,15 +399,17 @@ export class RoomWidgetClient extends MatrixClient {
             : event.getContent();
 
         // Delayed event special case.
-        if (delayOpts) {
+        if (delay !== undefined) {
             // TODO: updatePendingEvent for delayed events?
             const response = await this.widgetApi
                 .sendRoomEvent(
                     event.getType(),
                     content,
                     room.roomId,
-                    "delay" in delayOpts ? delayOpts.delay : undefined,
-                    "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined,
+                    delay,
+                    // TODO remove the parent_delay_id from the widget api.
+                    undefined,
+                    stickyDurationMs,
                 )
                 .catch(timeoutToConnectionError);
             return this.validateSendDelayedEventResponse(response);
@@ -386,7 +422,7 @@ export class RoomWidgetClient extends MatrixClient {
         let response: ISendEventFromWidgetResponseData;
         try {
             response = await this.widgetApi
-                .sendRoomEvent(event.getType(), content, room.roomId)
+                .sendRoomEvent(event.getType(), content, room.roomId, undefined, undefined, stickyDurationMs)
                 .catch(timeoutToConnectionError);
         } catch (e) {
             this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
@@ -425,7 +461,7 @@ export class RoomWidgetClient extends MatrixClient {
     // eslint-disable-next-line
     public async _unstable_sendDelayedStateEvent<K extends keyof StateEvents>(
         roomId: string,
-        delayOpts: SendDelayedEventRequestOpts,
+        delay: number,
         eventType: K,
         content: StateEvents[K],
         stateKey = "",
@@ -443,8 +479,9 @@ export class RoomWidgetClient extends MatrixClient {
                 stateKey,
                 content,
                 roomId,
-                "delay" in delayOpts ? delayOpts.delay : undefined,
-                "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined,
+                delay,
+                // TODO remove the parent_delay_id from the widget api.
+                undefined,
             )
             .catch(timeoutToConnectionError);
         return this.validateSendDelayedEventResponse(response);
@@ -704,6 +741,7 @@ export class RoomWidgetClient extends MatrixClient {
             }
 
             this.emit(ClientEvent.Event, event);
+            if (event.unstableStickyInfo !== undefined) this.room!._unstable_addStickyEvents([event]);
             this.setSyncState(SyncState.Syncing);
             logger.info(`Received event ${event.getId()} ${event.getType()}`);
         } else {
diff --git a/src/matrixrtc/MembershipManager.ts b/src/matrixrtc/MembershipManager.ts
index c06cd37c4b8..bbc4f213717 100644
--- a/src/matrixrtc/MembershipManager.ts
+++ b/src/matrixrtc/MembershipManager.ts
@@ -481,7 +481,7 @@ export class MembershipManager
     protected clientSendDelayedDisconnectMembership: () => Promise<SendDelayedEventResponse> = () =>
         this.client._unstable_sendDelayedStateEvent(
             this.room.roomId,
-            { delay: this.delayedLeaveEventDelayMs },
+            this.delayedLeaveEventDelayMs,
             EventType.GroupCallMemberPrefix,
             {},
             this.stateKey,
@@ -1062,7 +1062,7 @@ export class StickyEventMembershipManager extends MembershipManager {
         this.clientWithSticky._unstable_sendStickyDelayedEvent(
             this.room.roomId,
             MEMBERSHIP_STICKY_DURATION_MS,
-            { delay: this.delayedLeaveEventDelayMs },
+            this.delayedLeaveEventDelayMs,
             null,
             EventType.RTCMembership,
             { msc4354_sticky_key: this.memberId },
diff --git a/src/utils.ts b/src/utils.ts
index a6bcb3461fa..78f7dc04236 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -25,6 +25,7 @@ import { type IEvent, type MatrixEvent } from "./models/event.ts";
 import { M_TIMESTAMP } from "./@types/location.ts";
 import { ReceiptType } from "./@types/read_receipts.ts";
 import { type BaseLogger } from "./logger.ts";
+import { type SendDelayedEventRequestOpts, type SendStickyEventRequestOpts } from "./matrix.ts";
 
 const interns = new Map<string, string>();
 
@@ -78,12 +79,18 @@ export type QueryDict = Record<string, string[] | string | number | boolean | un
 /**
  * Replace a stable parameter with the unstable naming for params
  */
-export function replaceParam(stable: string, unstable: string, dict: QueryDict): QueryDict {
+export function replaceParam(
+    stable: string,
+    unstable: string,
+    dict: SendStickyEventRequestOpts | SendDelayedEventRequestOpts | QueryDict,
+): QueryDict {
+    const field = stable as keyof (SendStickyEventRequestOpts | SendDelayedEventRequestOpts | QueryDict);
     const result = {
         ...dict,
-        [unstable]: dict[stable],
+        [unstable]: dict[field],
     };
-    delete result[stable];
+
+    delete result[field];
     return result;
 }
 
diff --git a/yarn.lock b/yarn.lock
index a7103f76b92..7b70df53d42 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5449,9 +5449,9 @@ matrix-mock-request@^2.5.0:
     expect "^28.1.0"
 
 matrix-widget-api@^1.14.0:
-  version "1.15.0"
-  resolved "https://registry.yarnpkg.com/matrix-widget-api/-/matrix-widget-api-1.15.0.tgz#a508f72a5993a95382bdf890bd9e54525295b321"
-  integrity sha512-Yu9rX9wyF3A1sqviKgiYHz8aGgL3HhJe9OXKi/lccr1eZnNb6y+ELdbshTjs+VLKM4rkTWt6CE3THsw3f/CZhg==
+  version "1.16.0"
+  resolved "https://registry.yarnpkg.com/matrix-widget-api/-/matrix-widget-api-1.16.0.tgz#e232f1ed6b840feea58d693d877fb8a05b181aee"
+  integrity sha512-OCsCzEN54jWamvWkBa7PqcKdlOhLA+nJbUyqsATHvzb4/NMcjdUZWSDurZxyNE5eYlNwxClA6Hw20mzJEKJbvg==
   dependencies:
     "@types/events" "^3.0.0"
     events "^3.2.0"