@blocknote/xl-ai 0.44.1 → 0.45.0

package/src/streamTool/filterValidOperations.ts

@@ -29,6 +29,7 @@ export async function* filterValidOperations<T>(
   let forceNewOperation = false;
   for await (const chunk of operationsStream) {
     const operation = chunk.operation;
+
     if (operation.ok) {
       yield {
         operation: operation.value,

package/src/streamTool/preprocess.test.ts

@@ -1,10 +1,7 @@
 import { BlockNoteEditor } from "@blocknote/core";
 import { beforeEach, describe, expect, it } from "vitest";
 import { tools } from "../api/formats/json/tools/index.js";
-import {
-  preprocessOperationsNonStreaming,
-  preprocessOperationsStreaming,
-} from "./preprocess.js";
+import { preprocessOperationsStreaming } from "./preprocess.js";
 import { StreamTool } from "./streamTool.js";
 
 const addOperationValid = {
@@ -148,68 +145,37 @@ describe("preprocess", () => {
     });
   });
 
-  describe("preprocessOperationsNonStreaming", () => {
-    it("should pass valid operations", async () => {
-      async function* mockStream() {
-        yield {
-          partialOperation: addOperationValid,
-          isUpdateToPreviousOperation: false,
-          isPossiblyPartial: false,
-          metadata: undefined,
-        };
-      }
-
-      const results = await collectStreamToArray(
-        preprocessOperationsNonStreaming(mockStream(), streamTools),
-      );
-
-      expect(results.length).toBe(1);
-    });
-
-    it("should throw an error on invalid operations (invalid id)", async () => {
-      async function* mockStream() {
-        yield {
-          partialOperation: addOperationInvalidId,
-          isUpdateToPreviousOperation: false,
-          isPossiblyPartial: false,
-          metadata: undefined,
-        };
-      }
-
-      await expect(
-        collectStreamToArray(
-          preprocessOperationsNonStreaming(mockStream(), streamTools),
-        ),
-      ).rejects.toThrow();
-    });
-
-    it("should throw an error on invalid operations (invalid type)", async () => {
-      async function* mockStream() {
-        yield {
-          partialOperation: invalidOperationType,
-          isUpdateToPreviousOperation: false,
-          isPossiblyPartial: false,
-          metadata: undefined,
-        };
-      }
-
-      await expect(
-        collectStreamToArray(
-          preprocessOperationsNonStreaming(mockStream(), streamTools),
-        ),
-      ).rejects.toThrow();
-    });
-
-    it("should handle empty operation streams", async () => {
-      async function* mockStream() {
-        // Empty stream
-      }
-
-      const results = await collectStreamToArray(
-        preprocessOperationsNonStreaming(mockStream(), streamTools),
-      );
+  it("should throw an error on invalid operations (invalid id)", async () => {
+    async function* mockStream() {
+      yield {
+        partialOperation: addOperationInvalidId,
+        isUpdateToPreviousOperation: false,
+        isPossiblyPartial: false,
+        metadata: undefined,
+      };
+    }
+
+    await expect(
+      collectStreamToArray(
+        preprocessOperationsStreaming(mockStream(), streamTools),
+      ),
+    ).rejects.toThrow();
+  });
 
-      expect(results).toHaveLength(0);
-    });
+  it("should throw an error on invalid operations (invalid type)", async () => {
+    async function* mockStream() {
+      yield {
+        partialOperation: invalidOperationType,
+        isUpdateToPreviousOperation: false,
+        isPossiblyPartial: false,
+        metadata: undefined,
+      };
+    }
+
+    await expect(
+      collectStreamToArray(
+        preprocessOperationsStreaming(mockStream(), streamTools),
+      ),
+    ).rejects.toThrow();
   });
 });

package/src/streamTool/preprocess.ts

@@ -1,3 +1,4 @@
+import { getErrorMessage } from "@ai-sdk/provider-utils";
 import { ChunkExecutionError } from "./ChunkExecutionError.js";
 import { filterValidOperations } from "./filterValidOperations.js";
 import { StreamTool, StreamToolCall } from "./streamTool.js";
@@ -36,47 +37,16 @@ export async function* preprocessOperationsStreaming<
     (chunk) => {
       if (!chunk.isPossiblyPartial) {
         // only throw if the operation is not possibly partial
-        
-        throw new ChunkExecutionError("invalid operation: " + chunk.operation.error, chunk);
+        throw new ChunkExecutionError(
+          `Invalid operation. ${getErrorMessage(chunk.operation.error)}`,
+          chunk,
+          {
+            cause: chunk.operation.error,
+          },
+        );
       }
     },
   );
 
   yield* validOperationsStream;
 }
-
-/**
- * Validates an stream of operations and throws an error if an invalid operation is found.
- *
- * TODO: remove
- *
- * @deprecated
- */
-export async function* preprocessOperationsNonStreaming<
-  T extends StreamTool<any>[],
->(
-  operationsStream: AsyncIterable<{
-    partialOperation: any;
-    isUpdateToPreviousOperation: boolean;
-    isPossiblyPartial: boolean;
-    metadata: any;
-  }>,
-  streamTools: T,
-): AsyncGenerator<PreprocessOperationResult<T>> {
-  // from partial operations to valid / invalid operations
-  const validatedOperationsStream = toValidatedOperations(
-    operationsStream,
-    streamTools,
-  );
-
-  // filter valid operations, invalid operations should throw an error
-  const validOperationsStream = filterValidOperations(
-    validatedOperationsStream,
-    (chunk) => {
-      throw new Error("invalid operation: " + chunk.operation.error);
-    },
-  );
-
-  // yield results
-  yield* validOperationsStream;
-}

package/src/streamTool/toValidatedOperations.ts

@@ -22,6 +22,18 @@ export async function* toValidatedOperations<T extends StreamTool<any>[]>(
   metadata: any;
 }> {
   for await (const chunk of partialObjectStream) {
+    if (!chunk.partialOperation.type) {
+      yield {
+        operation: {
+          ok: false,
+          error: "The `type` property of an operation is required.",
+        },
+        isUpdateToPreviousOperation: chunk.isUpdateToPreviousOperation,
+        isPossiblyPartial: chunk.isPossiblyPartial,
+        metadata: chunk.metadata,
+      };
+      continue;
+    }
     const func = streamTools.find(
       (f) => f.name === chunk.partialOperation.type,
     )!;

package/src/streamTool/vercelAiSdk/util/chatHandlers.ts

@@ -129,6 +129,8 @@ export async function setupToolCallStreaming(
 
   if (result.status === "rejected") {
     if (result.reason instanceof ChunkExecutionError) {
+      // all errors thrown in the pipeline should be ChunkExecutionErrors,
+      // so we can retrieve the chunk that caused the error
       error = result.reason;
     } else {
       if (!chat.error) {

package/src/testUtil/cases/combinedOperationsTestCases.ts

@@ -39,7 +39,7 @@ export const combinedOperationsTestCases: DocumentOperationTestCase[] = [
         type: "update",
         id: "ref2",
         block: {
-          content: [{ type: "text", text: "Hallo", styles: {} }],
+          content: [{ type: "text", text: "Hallo,", styles: {} }],
         },
       },
     ],

package/src/testUtil/cases/editors/simpleEditor.ts

@@ -44,3 +44,18 @@ export function getSimpleEditorWithCursorBetweenBlocks() {
   editor.setTextCursorPosition("ref2");
   return editor;
 }
+
+export function getSimpleEditorSpellingError() {
+  const editor = BlockNoteEditor.create({
+    initialContent: [
+      {
+        id: "ref1",
+        content: "Hello, world! Dow are you?",
+      },
+    ],
+    trailingBlock: false,
+    schema,
+    extensions: [AIExtension()],
+  });
+  return editor;
+}

package/src/testUtil/cases/index.ts

@@ -1,5 +1,6 @@
 import {
   BlockNoteEditor,
+  expandPMRangeToWords,
   getNodeById,
   PartialBlock,
   updateBlockTr,
@@ -82,8 +83,12 @@ export function getExpectedEditor(
 
   for (const toolCall of testCase.baseToolCalls) {
     if (toolCall.type === "update") {
-      const selection = testCase.getTestSelection?.(editor);
+      let selection = testCase.getTestSelection?.(editor);
       if (selection) {
+        selection = expandPMRangeToWords(editor.prosemirrorState.doc, {
+          $from: editor.prosemirrorState.doc.resolve(selection.from),
+          $to: editor.prosemirrorState.doc.resolve(selection.to),
+        });
         editor.transact((tr) => {
           const pos = getNodeById(toolCall.id, tr.doc)!;
           // this is a bit of an ugly internal API, do we want to expose this (updating a selection)

package/src/testUtil/cases/updateOperationTestCases.ts

@@ -2,6 +2,7 @@ import { BlockNoteEditor, getBlockInfo, getNodeById } from "@blocknote/core";
 import { AIExtension } from "../../AIExtension.js";
 import { getEditorWithBlockFormatting } from "./editors/blockFormatting.js";
 import { getEditorWithFormattingAndMentions } from "./editors/formattingAndMentions.js";
+import { getSimpleEditorSpellingError } from "./editors/simpleEditor.js";
 import { DocumentOperationTestCase } from "./index.js";
 import { schemaWithMention as schema } from "./schemas/mention.js";
 
@@ -33,7 +34,7 @@ export const updateOperationTestCases: DocumentOperationTestCase[] = [
         type: "update",
         id: "ref2",
         block: {
-          content: [{ type: "text", text: "Hallo", styles: {} }],
+          content: [{ type: "text", text: "Hallo,", styles: {} }],
         },
       },
     ],
@@ -50,6 +51,34 @@ export const updateOperationTestCases: DocumentOperationTestCase[] = [
     },
     userPrompt: "translate to German",
   },
+  {
+    editor: getSimpleEditorSpellingError,
+    description: "fix spelling mid-word selection",
+    baseToolCalls: [
+      {
+        type: "update",
+        id: "ref1",
+        block: {
+          content: [
+            { type: "text", text: "Hello, world! How are you?", styles: {} },
+          ],
+        },
+      },
+    ],
+    getTestSelection: (editor: BlockNoteEditor<any, any, any>) => {
+      const posInfo = getNodeById("ref1", editor.prosemirrorState.doc)!;
+      const block = getBlockInfo(posInfo);
+      if (!block.isBlockContainer) {
+        throw new Error("Block is not a block container");
+      }
+      // 'ello, world! Dow are yo'
+      return {
+        from: block.blockContent.beforePos + 2,
+        to: block.blockContent.afterPos - 3,
+      };
+    },
+    userPrompt: "fix spelling",
+  },
   {
     editor: getEditorWithFormattingAndMentions,
     description: "update block type",

package/src/testUtil/suggestChangesTestUtil.ts

@@ -1,5 +1,5 @@
 import { BlockNoteEditor } from "@blocknote/core";
-import { revertSuggestions } from "@blocknote/prosemirror-suggest-changes";
+import { revertSuggestions } from "@handlewithcare/prosemirror-suggest-changes";
 import { Node } from "prosemirror-model";
 import { expect } from "vitest";
 

package/types/src/streamTool/preprocess.d.ts

@@ -14,16 +14,3 @@ export declare function preprocessOperationsStreaming<T extends StreamTool<any>[
     isPossiblyPartial: boolean;
     metadata: any;
 }>, streamTools: T): AsyncGenerator<PreprocessOperationResult<T>>;
-/**
- * Validates an stream of operations and throws an error if an invalid operation is found.
- *
- * TODO: remove
- *
- * @deprecated
- */
-export declare function preprocessOperationsNonStreaming<T extends StreamTool<any>[]>(operationsStream: AsyncIterable<{
-    partialOperation: any;
-    isUpdateToPreviousOperation: boolean;
-    isPossiblyPartial: boolean;
-    metadata: any;
-}>, streamTools: T): AsyncGenerator<PreprocessOperationResult<T>>;

package/types/src/testUtil/cases/editors/simpleEditor.d.ts

@@ -535,3 +535,271 @@ export declare function getSimpleEditorWithCursorBetweenBlocks(): BlockNoteEdito
         readonly propSchema: "string";
     }>;
 }>>;
+export declare function getSimpleEditorSpellingError(): BlockNoteEditor<import("@blocknote/core").BlockSchemaFromSpecs<{
+    readonly audio: import("@blocknote/core").BlockSpec<"audio", {
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly name: {
+            readonly default: "";
+        };
+        readonly url: {
+            readonly default: "";
+        };
+        readonly caption: {
+            readonly default: "";
+        };
+        readonly showPreview: {
+            readonly default: true;
+        };
+    }, "none">;
+    readonly bulletListItem: import("@blocknote/core").BlockSpec<"bulletListItem", {
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly checkListItem: import("@blocknote/core").BlockSpec<"checkListItem", {
+        readonly checked: {
+            readonly default: false;
+            readonly type: "boolean";
+        };
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly codeBlock: import("@blocknote/core").BlockSpec<"codeBlock", {
+        readonly language: {
+            readonly default: string;
+        };
+    }, "inline">;
+    readonly divider: import("@blocknote/core").BlockSpec<"divider", {}, "none">;
+    readonly file: import("@blocknote/core").BlockSpec<"file", {
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly name: {
+            readonly default: "";
+        };
+        readonly url: {
+            readonly default: "";
+        };
+        readonly caption: {
+            readonly default: "";
+        };
+    }, "none">;
+    readonly heading: import("@blocknote/core").BlockSpec<"heading", {
+        readonly isToggleable?: {
+            readonly default: false;
+            readonly optional: true;
+        } | undefined;
+        readonly level: {
+            readonly default: 1 | 4 | 2 | 3 | 5 | 6;
+            readonly values: readonly number[];
+        };
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly image: import("@blocknote/core").BlockSpec<"image", {
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly name: {
+            readonly default: "";
+        };
+        readonly url: {
+            readonly default: "";
+        };
+        readonly caption: {
+            readonly default: "";
+        };
+        readonly showPreview: {
+            readonly default: true;
+        };
+        readonly previewWidth: {
+            readonly default: undefined;
+            readonly type: "number";
+        };
+    }, "none">;
+    readonly numberedListItem: import("@blocknote/core").BlockSpec<"numberedListItem", {
+        readonly start: {
+            readonly default: undefined;
+            readonly type: "number";
+        };
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly paragraph: import("@blocknote/core").BlockSpec<"paragraph", {
+        backgroundColor: {
+            default: "default";
+        };
+        textColor: {
+            default: "default";
+        };
+        textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly quote: import("@blocknote/core").BlockSpec<"quote", {
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+    }, "inline">;
+    readonly table: import("@blocknote/core").LooseBlockSpec<"table", {
+        textColor: {
+            default: "default";
+        };
+    }, "table">;
+    readonly toggleListItem: import("@blocknote/core").BlockSpec<"toggleListItem", {
+        readonly backgroundColor: {
+            default: "default";
+        };
+        readonly textColor: {
+            default: "default";
+        };
+        readonly textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+    }, "inline">;
+    readonly video: import("@blocknote/core").BlockSpec<"video", {
+        textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+        backgroundColor: {
+            default: "default";
+        };
+        name: {
+            default: "";
+        };
+        url: {
+            default: "";
+        };
+        caption: {
+            default: "";
+        };
+        showPreview: {
+            default: boolean;
+        };
+        previewWidth: {
+            default: undefined;
+            type: "number";
+        };
+    }, "none">;
+}>, import("@blocknote/core").InlineContentSchemaFromSpecs<{
+    text: {
+        config: "text";
+        implementation: any;
+    };
+    link: {
+        config: "link";
+        implementation: any;
+    };
+}> & {
+    mention: {
+        type: string;
+        propSchema: {
+            user: {
+                default: string;
+            };
+        };
+        content: "none";
+    };
+}, import("@blocknote/core").StyleSchemaFromSpecs<{
+    bold: {
+        config: {
+            type: string;
+            propSchema: "boolean";
+        };
+        implementation: import("@blocknote/core").StyleImplementation<{
+            type: string;
+            propSchema: "boolean";
+        }>;
+    };
+    italic: {
+        config: {
+            type: string;
+            propSchema: "boolean";
+        };
+        implementation: import("@blocknote/core").StyleImplementation<{
+            type: string;
+            propSchema: "boolean";
+        }>;
+    };
+    underline: {
+        config: {
+            type: string;
+            propSchema: "boolean";
+        };
+        implementation: import("@blocknote/core").StyleImplementation<{
+            type: string;
+            propSchema: "boolean";
+        }>;
+    };
+    strike: {
+        config: {
+            type: string;
+            propSchema: "boolean";
+        };
+        implementation: import("@blocknote/core").StyleImplementation<{
+            type: string;
+            propSchema: "boolean";
+        }>;
+    };
+    code: {
+        config: {
+            type: string;
+            propSchema: "boolean";
+        };
+        implementation: import("@blocknote/core").StyleImplementation<{
+            type: string;
+            propSchema: "boolean";
+        }>;
+    };
+    textColor: import("@blocknote/core").StyleSpec<{
+        readonly type: "textColor";
+        readonly propSchema: "string";
+    }>;
+    backgroundColor: import("@blocknote/core").StyleSpec<{
+        readonly type: "backgroundColor";
+        readonly propSchema: "string";
+    }>;
+}>>;