@mastra/rag 0.1.19-alpha.3 → 0.1.19-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/rag",
-  "version": "0.1.19-alpha.3",
+  "version": "0.1.19-alpha.5",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -21,15 +21,13 @@
   "author": "",
   "license": "Elastic-2.0",
   "dependencies": {
-    "@llamaindex/core": "^0.6.2",
-    "@llamaindex/env": "^0.1.29",
     "@paralleldrive/cuid2": "^2.2.2",
     "js-tiktoken": "^1.0.19",
     "llamaindex": "^0.9.17",
     "node-html-better-parser": "^1.4.7",
     "pathe": "^2.0.3",
     "zod": "^3.24.2",
-    "@mastra/core": "^0.9.0-alpha.3"
+    "@mastra/core": "^0.9.0-alpha.5"
   },
   "peerDependencies": {
     "ai": "^4.0.0"

package/src/document/document.test.ts

@@ -1,6 +1,6 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import { embedMany } from 'ai';
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 
 import { MDocument } from './document';
 import { Language } from './types';
@@ -20,6 +20,8 @@ const openai = createOpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
 
+vi.setConfig({ testTimeout: 10_000, hookTimeout: 10_000 });
+
 describe('MDocument', () => {
   describe('basics', () => {
     let chunks: MDocument['chunks'];
@@ -1693,7 +1695,10 @@ describe('MDocument', () => {
       expect(metadata).toBeDefined();
       expect(metadata.documentTitle).toBeDefined();
       expect(metadata.sectionSummary).toBeDefined();
-      expect(metadata.questionsThisExcerptCanAnswer).toMatch(/^1\. .*\?2\. .*\?$/);
+      const qStr = metadata.questionsThisExcerptCanAnswer;
+      expect(qStr).toMatch(/1\..*\?/s);
+      expect(qStr).toMatch(/2\..*\?/s);
+      expect((qStr.match(/\?/g) || []).length).toBeGreaterThanOrEqual(2);
       expect(metadata.excerptKeywords).toMatch(/^1\. .*\n2\. .*\n3\. .*$/);
     }, 15000);
 
@@ -1711,6 +1716,122 @@ describe('MDocument', () => {
       ).rejects.toThrow("Summaries must be one of 'self', 'prev', 'next'");
     }, 15000);
   });
+
+  describe('metadata preservation', () => {
+    const baseText = 'This is a test document for metadata extraction.';
+    const baseMetadata = { source: 'unit-test', customField: 123 };
+
+    it('preserves metadata with KeywordExtractor', async () => {
+      const doc = MDocument.fromText(baseText, { ...baseMetadata });
+      const chunks = await doc.chunk({ extract: { keywords: true } });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.customField).toBe(123);
+      expect(metadata.excerptKeywords).toBeDefined();
+    });
+
+    it('preserves metadata with SummaryExtractor', async () => {
+      const doc = MDocument.fromText(baseText, { ...baseMetadata });
+      const chunks = await doc.chunk({ extract: { summary: true } });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.customField).toBe(123);
+      expect(metadata.sectionSummary).toBeDefined();
+    });
+
+    it('preserves metadata with QuestionsAnsweredExtractor', async () => {
+      const doc = MDocument.fromText(baseText, { ...baseMetadata });
+      const chunks = await doc.chunk({ extract: { questions: true } });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.customField).toBe(123);
+      expect(metadata.questionsThisExcerptCanAnswer).toBeDefined();
+    });
+
+    it('preserves metadata with TitleExtractor', async () => {
+      const doc = MDocument.fromText(baseText, { ...baseMetadata });
+      const chunks = await doc.chunk({ extract: { title: true } });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.customField).toBe(123);
+      expect(metadata.documentTitle).toBeDefined();
+    });
+
+    it('preserves metadata with multiple extractors', async () => {
+      const doc = MDocument.fromText(baseText, { ...baseMetadata });
+      const chunks = await doc.chunk({
+        extract: {
+          keywords: true,
+          summary: true,
+          questions: true,
+          title: true,
+        },
+      });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.customField).toBe(123);
+      expect(metadata.excerptKeywords).toBeDefined();
+      expect(metadata.sectionSummary).toBeDefined();
+      expect(metadata.questionsThisExcerptCanAnswer).toBeDefined();
+      expect(metadata.documentTitle).toBeDefined();
+    });
+    it('preserves metadata on all chunks when multiple are created', async () => {
+      const text = 'Chunk one.\n\nChunk two.\n\nChunk three.';
+      const doc = MDocument.fromText(text, { source: 'multi-chunk', customField: 42 });
+      const chunks = await doc.chunk({
+        strategy: 'character',
+        separator: '\n\n',
+        size: 20,
+        overlap: 0,
+        extract: { keywords: true },
+      });
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        const metadata = chunk.metadata;
+        expect(metadata.source).toBe('multi-chunk');
+        expect(metadata.customField).toBe(42);
+        expect(metadata.excerptKeywords).toBeDefined();
+      }
+    });
+
+    it('overwrites only the matching metadata field with extractor output', async () => {
+      const doc = MDocument.fromText('Test for overwrite', {
+        excerptKeywords: 'original,keywords',
+        unrelatedField: 'should stay',
+        source: 'unit-test',
+      });
+      const chunks = await doc.chunk({ extract: { keywords: true } });
+      const metadata = chunks[0].metadata;
+      expect(metadata.source).toBe('unit-test');
+      expect(metadata.unrelatedField).toBe('should stay');
+      expect(metadata.excerptKeywords).not.toBe('original,keywords'); // Should be new keywords
+    });
+  });
+  describe('MDocument TitleExtractor document grouping integration', () => {
+    it('groups chunks by docId for title extraction (integration)', async () => {
+      const doc = new MDocument({
+        docs: [
+          { text: 'Alpha chunk 1', metadata: { docId: 'docA' } },
+          { text: 'Alpha chunk 2', metadata: { docId: 'docA' } },
+          { text: 'Beta chunk 1', metadata: { docId: 'docB' } },
+        ],
+        type: 'text',
+      });
+
+      await doc.extractMetadata({ title: true });
+      const chunks = doc.getDocs();
+
+      const titleA1 = chunks[0].metadata.documentTitle;
+      const titleA2 = chunks[1].metadata.documentTitle;
+      const titleB = chunks[2].metadata.documentTitle;
+
+      expect(titleA1).toBeDefined();
+      expect(titleA2).toBeDefined();
+      expect(titleB).toBeDefined();
+      expect(titleA1).toBe(titleA2);
+      expect(titleA1).not.toBe(titleB);
+    });
+  });
 });
 
 // Helper function to find the longest common substring between two strings

package/src/document/document.ts

@@ -1,13 +1,6 @@
-import {
-  Document as Chunk,
-  IngestionPipeline,
-  KeywordExtractor,
-  QuestionsAnsweredExtractor,
-  SummaryExtractor,
-  TitleExtractor,
-  ObjectType,
-  NodeRelationship,
-} from 'llamaindex';
+import { Document as Chunk, IngestionPipeline, NodeRelationship, ObjectType } from 'llamaindex';
+
+import { TitleExtractor, SummaryExtractor, QuestionsAnsweredExtractor, KeywordExtractor } from './extractors';
 
 import { CharacterTransformer, RecursiveCharacterTransformer } from './transformers/character';
 import { HTMLHeaderTransformer, HTMLSectionTransformer } from './transformers/html';
@@ -45,18 +38,19 @@ export class MDocument {
 
     if (typeof title !== 'undefined') {
       transformations.push(new TitleExtractor(typeof title === 'boolean' ? {} : title));
-      this.chunks = this.chunks.map(
-        (doc, i) =>
-          new Chunk({
-            ...doc,
-            relationships: {
-              [NodeRelationship.SOURCE]: {
-                nodeId: `doc-${i}`,
-                nodeType: ObjectType.DOCUMENT,
-                metadata: doc.metadata,
+      this.chunks = this.chunks.map(doc =>
+        doc?.metadata?.docId
+          ? new Chunk({
+              ...doc,
+              relationships: {
+                [NodeRelationship.SOURCE]: {
+                  nodeId: doc.metadata.docId,
+                  nodeType: ObjectType.DOCUMENT,
+                  metadata: doc.metadata,
+                },
               },
-            },
-          }),
+            })
+          : doc,
       );
     }
 

package/src/document/extractors/index.ts

@@ -0,0 +1,5 @@
+export { TitleExtractor } from './title';
+export { SummaryExtractor } from './summary';
+export { QuestionsAnsweredExtractor } from './questions';
+export { KeywordExtractor } from './keywords';
+export * from './types';

package/src/document/extractors/keywords.test.ts

@@ -0,0 +1,119 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { TextNode } from 'llamaindex';
+import { describe, it, expect, vi } from 'vitest';
+import { KeywordExtractor } from './keywords';
+
+const openai = createOpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const model = openai('gpt-4o');
+
+vi.setConfig({ testTimeout: 10_000, hookTimeout: 10_000 });
+
+describe('KeywordExtractor', () => {
+  it('can use a custom model for keywords extraction', async () => {
+    const extractor = new KeywordExtractor({ llm: model });
+    const node = new TextNode({ text: 'The quick brown fox jumps over the lazy dog.' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles empty input gracefully', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result.excerptKeywords).toBe('');
+  });
+
+  it('supports prompt customization', async () => {
+    const extractor = new KeywordExtractor({
+      promptTemplate: 'List keywords in: {context}. Limit to {maxKeywords}.',
+    });
+    const node = new TextNode({ text: 'Test document for prompt customization.' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('extracts keywords from text', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: 'The quick brown fox jumps over the lazy dog.' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+  it('handles very long input', async () => {
+    const extractor = new KeywordExtractor();
+    const longText = 'A'.repeat(1000);
+    const node = new TextNode({ text: longText });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles whitespace only input', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '    ' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result.excerptKeywords).toBe('');
+  });
+
+  it('handles special characters and emojis', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '🚀✨🔥' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles numbers only', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '1234567890' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles HTML tags', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '<h1>Test</h1>' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles non-English text', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '这是一个测试文档。' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles duplicate/repeated text', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: 'repeat repeat repeat' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+
+  it('handles only punctuation', async () => {
+    const extractor = new KeywordExtractor();
+    const node = new TextNode({ text: '!!!???...' });
+    const result = await extractor.extractKeywordsFromNodes(node);
+    expect(result).toHaveProperty('excerptKeywords');
+    expect(typeof result.excerptKeywords).toBe('string');
+    expect(result.excerptKeywords.length).toBeGreaterThan(0);
+  });
+});

package/src/document/extractors/keywords.ts

@@ -0,0 +1,123 @@
+import type { MastraLanguageModel } from '@mastra/core/agent';
+import { PromptTemplate, defaultKeywordExtractPrompt, MetadataMode, TextNode, BaseExtractor } from 'llamaindex';
+import type { KeywordExtractPrompt, BaseNode } from 'llamaindex';
+import { baseLLM } from './types';
+import type { KeywordExtractArgs } from './types';
+
+type ExtractKeyword = {
+  /**
+   * Comma-separated keywords extracted from the node. May be empty if extraction fails.
+   */
+  excerptKeywords: string;
+};
+
+/**
+ * Extract keywords from a list of nodes.
+ */
+export class KeywordExtractor extends BaseExtractor {
+  /**
+   * MastraLanguageModel instance.
+   * @type {MastraLanguageModel}
+   */
+  llm: MastraLanguageModel;
+
+  /**
+   * Number of keywords to extract.
+   * @type {number}
+   * @default 5
+   */
+  keywords: number = 5;
+
+  /**
+   * The prompt template to use for the question extractor.
+   * @type {string}
+   */
+  promptTemplate: KeywordExtractPrompt;
+
+  /**
+   * Constructor for the KeywordExtractor class.
+   * @param {MastraLanguageModel} llm MastraLanguageModel instance.
+   * @param {number} keywords Number of keywords to extract.
+   * @param {string} [promptTemplate] Optional custom prompt template (must include {context})
+   * @throws {Error} If keywords is less than 1.
+   */
+  constructor(options?: KeywordExtractArgs) {
+    if (options?.keywords && options.keywords < 1) throw new Error('Keywords must be greater than 0');
+
+    super();
+
+    this.llm = options?.llm ?? baseLLM;
+    this.keywords = options?.keywords ?? 5;
+    this.promptTemplate = options?.promptTemplate
+      ? new PromptTemplate({
+          templateVars: ['context', 'maxKeywords'],
+          template: options.promptTemplate,
+        })
+      : defaultKeywordExtractPrompt;
+  }
+
+  /**
+   *
+   * @param node Node to extract keywords from.
+   * @returns Keywords extracted from the node.
+   */
+  /**
+   * Extract keywords from a node. Returns an object with a comma-separated string of keywords, or an empty string if extraction fails.
+   * Adds error handling for malformed/empty LLM output.
+   */
+  async extractKeywordsFromNodes(node: BaseNode): Promise<ExtractKeyword> {
+    const text = node.getContent(this.metadataMode);
+    if (!text || text.trim() === '') {
+      return { excerptKeywords: '' };
+    }
+    if (this.isTextNodeOnly && !(node instanceof TextNode)) {
+      return { excerptKeywords: '' };
+    }
+
+    let keywords = '';
+    try {
+      const completion = await this.llm.doGenerate({
+        inputFormat: 'messages',
+        mode: { type: 'regular' },
+        prompt: [
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: this.promptTemplate.format({
+                  context: node.getContent(MetadataMode.ALL),
+                  maxKeywords: this.keywords.toString(),
+                }),
+              },
+            ],
+          },
+        ],
+      });
+      if (typeof completion.text === 'string') {
+        keywords = completion.text.trim();
+      } else {
+        console.warn('Keyword extraction LLM output was not a string:', completion.text);
+      }
+    } catch (err) {
+      console.warn('Keyword extraction failed:', err);
+    }
+    return { excerptKeywords: keywords };
+  }
+
+  /**
+   *
+   * @param nodes Nodes to extract keywords from.
+   * @returns Keywords extracted from the nodes.
+   */
+  /**
+   * Extract keywords from an array of nodes. Always returns an array (may be empty).
+   * @param nodes Nodes to extract keywords from.
+   * @returns Array of keyword extraction results.
+   */
+  async extract(nodes: BaseNode[]): Promise<Array<ExtractKeyword>> {
+    if (!Array.isArray(nodes) || nodes.length === 0) return [];
+    const results = await Promise.all(nodes.map(node => this.extractKeywordsFromNodes(node)));
+    return results;
+  }
+}

package/src/document/extractors/questions.test.ts

@@ -0,0 +1,120 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { TextNode } from 'llamaindex';
+import { describe, it, expect, vi } from 'vitest';
+import { QuestionsAnsweredExtractor } from './questions';
+
+const openai = createOpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const model = openai('gpt-4o');
+
+vi.setConfig({ testTimeout: 10_000, hookTimeout: 10_000 });
+
+describe('QuestionsAnsweredExtractor', () => {
+  it('can use a custom model for questions extraction', async () => {
+    const extractor = new QuestionsAnsweredExtractor({ llm: model });
+    const node = new TextNode({ text: 'What is the capital of Spain?' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('extracts questions', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: 'What is the capital of France? What is the color of the sky?' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles empty input gracefully', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(result.questionsThisExcerptCanAnswer).toBe('');
+  });
+
+  it('supports prompt customization', async () => {
+    const extractor = new QuestionsAnsweredExtractor({
+      promptTemplate: 'List questions in: {context}. Limit to {numQuestions}.',
+    });
+    const node = new TextNode({ text: 'Test document for prompt customization.' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+  it('handles very long input', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const longText = 'A'.repeat(1000);
+    const node = new TextNode({ text: longText });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles whitespace only input', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '    ' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result.questionsThisExcerptCanAnswer).toBe('');
+  });
+
+  it('handles special characters and emojis', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '🚀✨🔥' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles numbers only', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '1234567890' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles HTML tags', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '<h1>Test</h1>' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles non-English text', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '这是一个测试文档。' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles duplicate/repeated text', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: 'repeat repeat repeat' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+
+  it('handles only punctuation', async () => {
+    const extractor = new QuestionsAnsweredExtractor();
+    const node = new TextNode({ text: '!!!???...' });
+    const result = await extractor.extractQuestionsFromNode(node);
+    expect(result).toHaveProperty('questionsThisExcerptCanAnswer');
+    expect(typeof result.questionsThisExcerptCanAnswer).toBe('string');
+    expect(result.questionsThisExcerptCanAnswer.length).toBeGreaterThan(0);
+  });
+});