@liveblocks/core 2.17.0-usrnotsettings3 → 2.18.0-yjsfactory

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.17.0-usrnotsettings3";
+var PKG_VERSION = "2.18.0-yjsfactory";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -1562,6 +1562,29 @@ function createApiClient({
       }
     );
   }
+  async function executeContextualPrompt(options) {
+    const result = await httpClient.post(
+      url`/v2/c/rooms/${options.roomId}/ai/contextual-prompt`,
+      await authManager.getAuthValue({
+        requestedScope: "room:read",
+        roomId: options.roomId
+      }),
+      {
+        prompt: options.prompt,
+        context: {
+          beforeSelection: options.context.beforeSelection,
+          selection: options.context.selection,
+          afterSelection: options.context.afterSelection
+        },
+        previous: options.previous
+      },
+      { signal: options.signal }
+    );
+    if (!result || result.content.length === 0) {
+      throw new Error("No content returned from server");
+    }
+    return result.content[0].text;
+  }
   async function listTextVersions(options) {
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/versions`,
@@ -1819,7 +1842,9 @@ function createApiClient({
     updateUserNotificationSettings,
     // User threads
     getUserThreads_experimental,
-    getUserThreadsSince_experimental
+    getUserThreadsSince_experimental,
+    // AI
+    executeContextualPrompt
   };
 }
 function getBearerTokenFromAuthValue(authValue) {
@@ -6345,7 +6370,7 @@ function defaultMessageFromContext(context) {
 }
 
 // src/room.ts
-var MAX_SOCKET_MESSAGE_SIZE = 1024 * 1024 - 1024;
+var MAX_SOCKET_MESSAGE_SIZE = 1024 * 1024 - 512;
 function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
@@ -6586,7 +6611,8 @@ function createRoom(options, config) {
     storageDidLoad: makeEventSource(),
     storageStatus: makeEventSource(),
     ydoc: makeEventSource(),
-    comments: makeEventSource()
+    comments: makeEventSource(),
+    roomWillDestroy: makeEventSource()
   };
   const roomId = config.roomId;
   async function createTextMention(userId, mentionId) {
@@ -6614,24 +6640,88 @@ function createRoom(options, config) {
   async function createTextVersion() {
     return httpClient.createTextVersion({ roomId });
   }
+  async function executeContextualPrompt(options2) {
+    return httpClient.executeContextualPrompt({
+      roomId,
+      ...options2
+    });
+  }
+  function* chunkOps(msg) {
+    const { ops, ...rest } = msg;
+    if (ops.length < 2) {
+      throw new Error("Cannot split ops into smaller chunks");
+    }
+    const mid = Math.floor(ops.length / 2);
+    const firstHalf = ops.slice(0, mid);
+    const secondHalf = ops.slice(mid);
+    for (const halfOps of [firstHalf, secondHalf]) {
+      const half = { ops: halfOps, ...rest };
+      const text = JSON.stringify([half]);
+      if (!isTooBigForWebSocket(text)) {
+        yield text;
+      } else {
+        yield* chunkOps(half);
+      }
+    }
+  }
+  function* chunkMessages(messages) {
+    if (messages.length < 2) {
+      if (messages[0].type === 201 /* UPDATE_STORAGE */) {
+        yield* chunkOps(messages[0]);
+        return;
+      } else {
+        throw new Error(
+          "Cannot split into chunks smaller than the allowed message size"
+        );
+      }
+    }
+    const mid = Math.floor(messages.length / 2);
+    const firstHalf = messages.slice(0, mid);
+    const secondHalf = messages.slice(mid);
+    for (const half of [firstHalf, secondHalf]) {
+      const text = JSON.stringify(half);
+      if (!isTooBigForWebSocket(text)) {
+        yield text;
+      } else {
+        yield* chunkMessages(half);
+      }
+    }
+  }
+  function isTooBigForWebSocket(text) {
+    if (text.length * 4 < MAX_SOCKET_MESSAGE_SIZE) {
+      return false;
+    }
+    return new TextEncoder().encode(text).length >= MAX_SOCKET_MESSAGE_SIZE;
+  }
   function sendMessages(messages) {
-    const serializedPayload = JSON.stringify(messages);
-    const nonce = context.dynamicSessionInfoSig.get()?.nonce;
-    if (config.unstable_fallbackToHTTP && nonce) {
-      const size = new TextEncoder().encode(serializedPayload).length;
-      if (size > MAX_SOCKET_MESSAGE_SIZE) {
+    const strategy = config.largeMessageStrategy ?? "default";
+    const text = JSON.stringify(messages);
+    if (!isTooBigForWebSocket(text)) {
+      return managedSocket.send(text);
+    }
+    switch (strategy) {
+      case "default": {
+        error2("Message is too large for websockets, not sending. Configure largeMessageStrategy option to deal with this.");
+        return;
+      }
+      case "split": {
+        warn("Message is too large for websockets, splitting into smaller chunks");
+        for (const chunk2 of chunkMessages(messages)) {
+          managedSocket.send(chunk2);
+        }
+        return;
+      }
+      case "experimental-fallback-to-http": {
+        warn("Message is too large for websockets, so sending over HTTP instead");
+        const nonce = context.dynamicSessionInfoSig.get()?.nonce ?? raise("Session is not authorized to send message over HTTP");
         void httpClient.sendMessages({ roomId, nonce, messages }).then((resp) => {
           if (!resp.ok && resp.status === 403) {
             managedSocket.reconnect();
           }
         });
-        warn(
-          "Message was too large for websockets and sent over HTTP instead"
-        );
         return;
       }
     }
-    managedSocket.send(serializedPayload);
   }
   const self = DerivedSignal.from(
     context.staticSessionInfoSig,
@@ -7427,7 +7517,8 @@ ${Array.from(traces).join("\n\n")}`
     storageDidLoad: eventHub.storageDidLoad.observable,
     storageStatus: eventHub.storageStatus.observable,
     ydoc: eventHub.ydoc.observable,
-    comments: eventHub.comments.observable
+    comments: eventHub.comments.observable,
+    roomWillDestroy: eventHub.roomWillDestroy.observable
   };
   async function getThreadsSince(options2) {
     return httpClient.getThreadsSince({
@@ -7598,6 +7689,8 @@ ${Array.from(traces).join("\n\n")}`
         getTextVersion,
         // create a version
         createTextVersion,
+        // execute a contextual prompt
+        executeContextualPrompt,
         // Support for the Liveblocks browser extension
         getSelf_forDevTools: () => selfAsTreeNode.get(),
         getOthers_forDevTools: () => others_forDevTools.get(),
@@ -7619,11 +7712,17 @@ ${Array.from(traces).join("\n\n")}`
       reconnect: () => managedSocket.reconnect(),
       disconnect: () => managedSocket.disconnect(),
       destroy: () => {
-        syncSourceForStorage.destroy();
+        const { roomWillDestroy, ...eventsExceptDestroy } = eventHub;
+        for (const source of Object.values(eventsExceptDestroy)) {
+          source[Symbol.dispose]();
+        }
+        eventHub.roomWillDestroy.notify();
         context.yjsProvider?.off("status", yjsStatusDidChange);
+        syncSourceForStorage.destroy();
         syncSourceForYjs.destroy();
         uninstallBgTabSpy();
         managedSocket.destroy();
+        roomWillDestroy[Symbol.dispose]();
       },
       // Presence
       updatePresence,
@@ -7902,7 +8001,7 @@ function createClient(options) {
         enableDebugLogging: clientOptions.enableDebugLogging,
         baseUrl,
         errorEventSource: liveblocksErrorSource,
-        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP,
+        largeMessageStrategy: clientOptions.largeMessageStrategy ?? (clientOptions.unstable_fallbackToHTTP ? "experimental-fallback-to-http" : void 0),
         unstable_streamData: !!clientOptions.unstable_streamData,
         roomHttpClient: httpClient,
         createSyncSource