@eeacms/volto-eea-chatbot 3.0.0 → 4.0.0

package/src/halloumi/generative.test.js

@@ -1,386 +0,0 @@
-import {
-  halloumiGenerativeAPI,
-  convertGenerativesClaimToVerifyClaimResponse,
-  applyPlattScaling,
-  getVerifyClaimResponse,
-} from './generative';
-import path from 'path';
-
-jest.mock('node-fetch');
-
-describe('halloumiGenerativeAPI reads from mock file', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    jest.resetModules(); // Most important - reset modules between test runs
-    process.env = {
-      ...originalEnv,
-      MOCK_HALLOUMI_FILE_PATH: path.join(__dirname, '../dummy/qa-raw-3.json'),
-    };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv; // Restore original env
-    jest.restoreAllMocks(); // Restore all mocks
-  });
-
-  it('should read from the mock file when MOCK_LLM_CALL is true', async () => {
-    const model = { name: 'test-model', apiUrl: 'http://test.com' };
-    const prompt = {
-      prompt: 'test-prompt',
-      contextOffsets: new Map([[1, { startOffset: 0, endOffset: 10 }]]),
-      responseOffsets: new Map([[1, { startOffset: 0, endOffset: 20 }]]),
-    };
-
-    // We are testing halloumiGenerativeAPI which internally calls getLLMResponse
-    // and getLLMResponse uses the MOCK_LLM_CALL env variable.
-    const response = await halloumiGenerativeAPI(model, prompt);
-
-    expect(response[0].claimString).toEqual(
-      '**France – total waste generation (latest available data)**  \n',
-    );
-    expect(response[0].segments).toEqual([
-      38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-    ]);
-  });
-});
-
-describe('applyPlattScaling', () => {
-  it('returns calibrated probability', () => {
-    const platt = { a: -0.5764, b: 0.1665 };
-    const result = applyPlattScaling(platt, 0.5);
-    expect(result).toBeGreaterThan(0);
-    expect(result).toBeLessThan(1);
-  });
-
-  it('clamps very low probability', () => {
-    const platt = { a: -1, b: 0 };
-    const result = applyPlattScaling(platt, 0);
-    expect(result).toBeGreaterThan(0);
-    expect(result).toBeLessThan(1);
-  });
-
-  it('clamps very high probability', () => {
-    const platt = { a: -1, b: 0 };
-    const result = applyPlattScaling(platt, 1);
-    expect(result).toBeGreaterThan(0);
-    expect(result).toBeLessThan(1);
-  });
-
-  it('returns 0.5 when platt params are zero', () => {
-    const platt = { a: 0, b: 0 };
-    const result = applyPlattScaling(platt, 0.5);
-    expect(result).toBeCloseTo(0.5, 1);
-  });
-});
-
-describe('getVerifyClaimResponse', () => {
-  it('returns empty response when sources is empty', async () => {
-    const result = await getVerifyClaimResponse({}, [], 'claims');
-    expect(result).toEqual({
-      claims: [],
-      segments: {},
-      reason: 'Context is empty',
-    });
-  });
-
-  it('returns empty response when sources is null', async () => {
-    const result = await getVerifyClaimResponse({}, null, 'claims');
-    expect(result).toEqual({
-      claims: [],
-      segments: {},
-      reason: 'Context is empty',
-    });
-  });
-
-  it('returns empty response when claims is falsy', async () => {
-    const result = await getVerifyClaimResponse({}, ['source'], null);
-    expect(result).toEqual({
-      claims: [],
-      segments: {},
-      reason: 'Context is empty',
-    });
-  });
-});
-
-describe('halloumiGenerativeAPI with plattScaling', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    jest.resetModules();
-    process.env = {
-      ...originalEnv,
-      MOCK_HALLOUMI_FILE_PATH: path.join(__dirname, '../dummy/qa-raw-3.json'),
-    };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    jest.restoreAllMocks();
-  });
-
-  it('applies platt scaling when model has plattScaling config', async () => {
-    const model = {
-      name: 'test-model',
-      apiUrl: 'http://test.com',
-      plattScaling: { a: -0.5764, b: 0.1665 },
-    };
-    const prompt = {
-      prompt: 'test-prompt',
-      contextOffsets: new Map([[1, { startOffset: 0, endOffset: 10 }]]),
-      responseOffsets: new Map([[1, { startOffset: 0, endOffset: 20 }]]),
-    };
-
-    const response = await halloumiGenerativeAPI(model, prompt);
-
-    // With platt scaling, probabilities should be calibrated
-    expect(response[0].probabilities).toBeDefined();
-    const supported = response[0].probabilities.get('supported');
-    const unsupported = response[0].probabilities.get('unsupported');
-    expect(supported + unsupported).toBeCloseTo(1, 5);
-  });
-});
-
-describe('halloumiGenerativeAPI via real fetch', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    jest.resetModules();
-    // Remove mock file path to exercise the fetch path
-    process.env = { ...originalEnv };
-    delete process.env.MOCK_HALLOUMI_FILE_PATH;
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    jest.restoreAllMocks();
-  });
-
-  it('calls fetch with correct parameters and auth header', async () => {
-    // Mock postprocessing to control output and avoid format issues
-    jest.doMock('./postprocessing', () => ({
-      getClaimsFromResponse: jest.fn(() => [
-        {
-          claimId: 1,
-          claimString: 'Test claim',
-          subclaims: [],
-          segments: [1],
-          explanation: 'ok',
-          supported: true,
-        },
-      ]),
-      getTokenProbabilitiesFromLogits: jest.fn(() => [
-        new Map([
-          ['supported', 0.9],
-          ['unsupported', 0.1],
-        ]),
-      ]),
-    }));
-
-    const { halloumiGenerativeAPI } = require('./generative');
-    const nodeFetch = require('node-fetch');
-
-    const mockResponse = {
-      choices: [
-        {
-          message: { content: 'mock content' },
-          logprobs: { content: [] },
-        },
-      ],
-    };
-
-    nodeFetch.mockResolvedValueOnce({
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const model = {
-      name: 'test-model',
-      apiUrl: 'http://test.com/api',
-      apiKey: 'test-key',
-    };
-    const prompt = {
-      prompt: 'test prompt',
-      contextOffsets: new Map([[1, { startOffset: 0, endOffset: 10 }]]),
-      responseOffsets: new Map([[1, { startOffset: 0, endOffset: 20 }]]),
-    };
-
-    const response = await halloumiGenerativeAPI(model, prompt);
-    expect(response).toBeDefined();
-    expect(Array.isArray(response)).toBe(true);
-    expect(response[0].probabilities.get('supported')).toBe(0.9);
-
-    // Verify fetch was called with auth header
-    expect(nodeFetch).toHaveBeenCalledWith(
-      'http://test.com/api',
-      expect.objectContaining({
-        method: 'POST',
-        headers: expect.objectContaining({
-          Authorization: 'Bearer test-key',
-        }),
-      }),
-    );
-  });
-
-  it('calls fetch without auth header when no apiKey', async () => {
-    jest.doMock('./postprocessing', () => ({
-      getClaimsFromResponse: jest.fn(() => [
-        {
-          claimId: 1,
-          claimString: 'Test',
-          subclaims: [],
-          segments: [],
-          explanation: 'ok',
-          supported: true,
-        },
-      ]),
-      getTokenProbabilitiesFromLogits: jest.fn(() => [
-        new Map([
-          ['supported', 0.8],
-          ['unsupported', 0.2],
-        ]),
-      ]),
-    }));
-
-    const { halloumiGenerativeAPI } = require('./generative');
-    const nodeFetch = require('node-fetch');
-
-    nodeFetch.mockResolvedValueOnce({
-      json: () =>
-        Promise.resolve({
-          choices: [
-            {
-              message: { content: 'mock' },
-              logprobs: { content: [] },
-            },
-          ],
-        }),
-    });
-
-    const model = { name: 'test-model', apiUrl: 'http://test.com/api' };
-    const prompt = {
-      prompt: 'test',
-      contextOffsets: new Map(),
-      responseOffsets: new Map(),
-    };
-
-    await halloumiGenerativeAPI(model, prompt);
-
-    const callHeaders = nodeFetch.mock.calls[0][1].headers;
-    expect(callHeaders.Authorization).toBeUndefined();
-  });
-
-  it('defaults to 0.5 when token probabilities and claims do not match', async () => {
-    jest.doMock('./postprocessing', () => ({
-      getClaimsFromResponse: jest.fn(() => [
-        { claimId: 1, claimString: 'Claim 1' },
-        { claimId: 2, claimString: 'Claim 2' },
-      ]),
-      getTokenProbabilitiesFromLogits: jest.fn(() => [
-        new Map([['supported', 0.9]]),
-      ]),
-    }));
-
-    const { halloumiGenerativeAPI } = require('./generative');
-    const nodeFetch = require('node-fetch');
-
-    nodeFetch.mockResolvedValueOnce({
-      json: () =>
-        Promise.resolve({
-          choices: [
-            {
-              message: { content: 'mock' },
-              logprobs: { content: [] },
-            },
-          ],
-        }),
-    });
-
-    const model = { name: 'test-model', apiUrl: 'http://test.com' };
-    const prompt = {
-      prompt: 'test',
-      contextOffsets: new Map(),
-      responseOffsets: new Map(),
-    };
-
-    const result = await halloumiGenerativeAPI(model, prompt);
-    // First claim gets the available probability
-    expect(result[0].probabilities.get('supported')).toBe(0.9);
-    // Second claim defaults to 0.5
-    expect(result[1].probabilities.get('supported')).toBe(0.5);
-  });
-});
-
-describe('convertGenerativesClaimToVerifyClaimResponse', () => {
-  it('should correctly convert generative claims to verify claim response', () => {
-    const generativeClaims = [
-      {
-        claimId: 1,
-        claimString: 'Test claim string',
-        subclaims: ['subclaim1', 'subclaim2'],
-        segments: [1, 2, 3],
-        explanation: 'Test explanation',
-        supported: true,
-        probabilities: new Map([
-          ['supported', 0.9],
-          ['unsupported', 0.1],
-        ]),
-      },
-    ];
-
-    const prompt = {
-      contextOffsets: new Map([[1, { startOffset: 0, endOffset: 10 }]]),
-      responseOffsets: new Map([[1, { startOffset: 100, endOffset: 120 }]]),
-      joinedContext: 'Test conte',
-    };
-
-    const result = convertGenerativesClaimToVerifyClaimResponse(
-      generativeClaims,
-      prompt,
-    );
-
-    expect(result).toEqual({
-      claims: [
-        {
-          claimId: 1,
-          claimString: 'Test claim string',
-          startOffset: 100,
-          endOffset: 120,
-          rationale: 'Test explanation',
-          segmentIds: ['1', '2', '3'],
-          score: 0.9,
-        },
-      ],
-      segments: {
-        1: {
-          id: '1',
-          startOffset: 0,
-          endOffset: 10,
-          text: 'Test conte',
-        },
-      },
-    });
-  });
-
-  it('throws when claim ID is not found in response offsets', () => {
-    const generativeClaims = [
-      {
-        claimId: 999,
-        claimString: 'Unknown claim',
-        subclaims: [],
-        segments: [],
-        explanation: 'Missing',
-        supported: false,
-        probabilities: new Map([['supported', 0.1]]),
-      },
-    ];
-
-    const prompt = {
-      contextOffsets: new Map(),
-      responseOffsets: new Map(),
-    };
-
-    expect(() =>
-      convertGenerativesClaimToVerifyClaimResponse(generativeClaims, prompt),
-    ).toThrow('Claim 999 not found in response offsets');
-  });
-});

package/src/halloumi/markdown-splitter.js

@@ -1,172 +0,0 @@
-import nlp from 'compromise';
-
-const MIN_SENTENCE_LENGTH = 15;
-
-/**
- * Splits markdown text into segments meaningful for fact-checking.
- *
- * Strategy:
- * 1. Split into markdown blocks (paragraphs, list items, table rows, headers)
- * 2. For prose blocks, further split into sentences using Intl.Segmenter
- * 3. Merge short fragments (< MIN_SENTENCE_LENGTH) into the next sentence
- *
- * Structural blocks (table rows, headers, list items) are kept as-is since
- * they are already atomic units.
- *
- * @param {string} text Markdown text to split.
- * @returns {string[]} Array of segment strings.
- */
-export function splitMarkdown(text) {
-  const blocks = splitIntoBlocks(text);
-  const segments = [];
-
-  for (const block of blocks) {
-    if (isStructuralBlock(block)) {
-      if (block.trim().length > 0) {
-        segments.push(block);
-      }
-    } else {
-      segments.push(...splitProse(block));
-    }
-  }
-
-  return segments;
-}
-
-/**
- * Splits markdown text into structural blocks.
- * Separates: headers, table rows, list items, horizontal rules, and prose.
- * Prose lines within the same paragraph are joined together.
- */
-function splitIntoBlocks(text) {
-  const lines = text.split('\n');
-  const blocks = [];
-  let currentProse = '';
-
-  const flushProse = () => {
-    if (currentProse) {
-      blocks.push(currentProse);
-      currentProse = '';
-    }
-  };
-
-  for (const line of lines) {
-    const trimmed = line.trimStart();
-
-    if (isTableRow(trimmed)) {
-      flushProse();
-      blocks.push(line);
-    } else if (isTableSeparator(trimmed)) {
-      flushProse();
-      // Skip separator rows — not verifiable content
-    } else if (isHeader(trimmed)) {
-      flushProse();
-      blocks.push(line);
-    } else if (isHorizontalRule(trimmed)) {
-      flushProse();
-      // Skip horizontal rules
-    } else if (isListItem(trimmed)) {
-      flushProse();
-      blocks.push(line);
-    } else if (trimmed === '') {
-      flushProse();
-    } else {
-      // Prose continuation — join into a single paragraph
-      currentProse += (currentProse ? ' ' : '') + line.trim();
-    }
-  }
-
-  flushProse();
-  return blocks;
-}
-
-function isTableRow(line) {
-  return /^\|.*\|/.test(line) && !isTableSeparator(line);
-}
-
-function isTableSeparator(line) {
-  return /^\|[\s\-:|]+\|$/.test(line);
-}
-
-function isHeader(line) {
-  return /^#{1,6}\s/.test(line);
-}
-
-function isHorizontalRule(line) {
-  return /^(\*{3,}|-{3,}|_{3,})\s*$/.test(line);
-}
-
-function isListItem(line) {
-  return /^(\d+\.\s+|[-*+]\s+)/.test(line);
-}
-
-/**
- * Returns true if a block is structural (table row, header, list item)
- * and should not be further split into sentences.
- */
-function isStructuralBlock(block) {
-  const trimmed = block.trimStart();
-  return isTableRow(trimmed) || isHeader(trimmed) || isListItem(trimmed);
-}
-
-/**
- * Splits a prose paragraph into sentences using sbd (sentence boundary detection),
- * merging short fragments that aren't independently verifiable.
- * sbd handles abbreviations (Dr., Mr., U.S., Ph.D.) correctly.
- */
-export function splitProse(text, maxSentences = 0) {
-  // const segments = segment('en', text);
-  const doc = nlp(text);
-  const initialSentences = doc.sentences().out('array');
-
-  // Find each sentence's position in the original text
-  const positions = getPositions(text, initialSentences);
-
-  // Merge short sentences (< MIN_SENTENCE_LENGTH) into the next sentence
-  const merged = [];
-  const mergedPositions = [];
-  let pendingStart = null;
-  for (let i = 0; i < initialSentences.length; i++) {
-    if (pendingStart === null) {
-      pendingStart = positions[i].start;
-    }
-    if (
-      initialSentences[i].replaceAll('\n', '').length < MIN_SENTENCE_LENGTH &&
-      i < initialSentences.length - 1
-    ) {
-      // Too short — will be merged with the next sentence
-      continue;
-    }
-    const s = text.slice(pendingStart, positions[i].end);
-    merged.push(s);
-    mergedPositions.push({ start: pendingStart, end: positions[i].end });
-    pendingStart = null;
-  }
-
-  if (maxSentences && merged.length > maxSentences) {
-    // Merge groups by slicing original text to preserve separators
-    const groupSize = Math.ceil(merged.length / maxSentences);
-    const groupedSentences = [];
-    for (let i = 0; i < merged.length; i += groupSize) {
-      const groupStart = mergedPositions[i].start;
-      const groupEnd =
-        mergedPositions[Math.min(i + groupSize, merged.length) - 1].end;
-      groupedSentences.push(text.slice(groupStart, groupEnd));
-    }
-    return groupedSentences;
-  }
-
-  return merged;
-}
-
-function getPositions(text, sentences) {
-  const positions = [];
-  let searchFrom = 0;
-  for (const sentence of sentences) {
-    const start = text.indexOf(sentence, searchFrom);
-    const end = start + sentence.length;
-    positions.push({ start, end });
-    searchFrom = end;
-  }
-  return positions;
-}

package/src/halloumi/markdown-splitter.test.js

@@ -1,133 +0,0 @@
-import { splitMarkdown } from './markdown-splitter';
-
-const DUMMY_LLM_RESPONSE = `## European species most at risk
-
-Below is a concise, evidence-based snapshot of the taxonomic groups and flagship species. The list combines information on trend magnitude and risk status.
-
-| Taxonomic group | Species at risk | Main drivers | Signal |
-|-----------------|-----------------|--------------|--------|
-| **Birds** | Skylark (*Alauda arvensis*), European turtle-dove | Intensive agriculture, pesticide use | Farmland-bird index down 27% (1990-2019) |
-| **Fish** | Houting (*Coregonus oxyrhynchus*), Danube salmon | River regulation, dam construction | Both listed as critically endangered |
-| **Butterflies** | Large blue (*Phengaris arion*), Adonis blue | Loss of semi-natural grasslands | Grassland-butterfly index down 25% |
-
-### Key take-aways
-
-1. **Agricultural intensification** is the single biggest pressure across taxa.
-2. **Habitat loss and degradation** underlie the perilous status of many specialists.
-3. **Chemical stressors** affect both insects and the birds that depend on them.
-4. **Climate change** amplifies existing pressures such as drought stress on amphibians.
-
----
-
-### Conservation priorities
-
-- **Protect and restore semi-natural habitats** including high-diversity grasslands and river floodplains.
-- **Implement agri-environment schemes** that limit pesticide use and maintain field margins.
-- **Focus monitoring on flagship species** to gauge the effectiveness of policy actions.
-
-If you need a deeper dive into a particular taxon, just let me know!`;
-
-describe('splitMarkdown', () => {
-  it('should split the dummy LLM response into meaningful segments', () => {
-    const segments = splitMarkdown(DUMMY_LLM_RESPONSE);
-
-    // Headers are separate segments
-    expect(segments).toContain('## European species most at risk');
-    expect(segments).toContain('### Key take-aways');
-    expect(segments).toContain('### Conservation priorities');
-
-    // Table rows are individual segments (separator skipped)
-    const tableRows = segments.filter((s) => s.startsWith('|'));
-    expect(tableRows.length).toBe(4); // header row + 3 data rows
-
-    // Numbered list items are separate
-    const numberedItems = segments.filter((s) => /^\d+\./.test(s.trimStart()));
-    expect(numberedItems.length).toBe(4);
-
-    // Bullet list items are separate
-    const bulletItems = segments.filter((s) => /^-\s/.test(s.trimStart()));
-    expect(bulletItems.length).toBe(3);
-
-    // Prose paragraphs are split into sentences
-    expect(segments).toContainEqual(
-      expect.stringContaining('evidence-based snapshot'),
-    );
-    expect(segments).toContainEqual(expect.stringContaining('trend magnitude'));
-
-    // Horizontal rules are skipped
-    expect(segments).not.toContainEqual(expect.stringMatching(/^-{3,}$/));
-
-    // No empty segments
-    expect(segments.every((s) => s.trim().length > 0)).toBe(true);
-  });
-
-  it('should handle plain prose without markdown', () => {
-    const text =
-      'This is sentence one. This is sentence two. This is sentence three.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual([
-      'This is sentence one.',
-      'This is sentence two.',
-      'This is sentence three.',
-    ]);
-  });
-
-  it('should handle headers followed by prose', () => {
-    const text = '## My Header\n\nSome prose paragraph here.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual(['## My Header', 'Some prose paragraph here.']);
-  });
-
-  it('should skip table separator rows', () => {
-    const text = '| A | B |\n|---|---|\n| 1 | 2 |';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual(['| A | B |', '| 1 | 2 |']);
-  });
-
-  it('should handle numbered lists', () => {
-    const text =
-      '1. First item with enough text.\n2. Second item also long enough.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual([
-      '1. First item with enough text.',
-      '2. Second item also long enough.',
-    ]);
-  });
-
-  it('should handle bullet lists', () => {
-    const text =
-      '- First bullet point.\n- Second bullet point.\n- Third bullet point.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual([
-      '- First bullet point.',
-      '- Second bullet point.',
-      '- Third bullet point.',
-    ]);
-  });
-
-  it('should skip horizontal rules', () => {
-    const text = 'Before the rule.\n\n---\n\nAfter the rule.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual(['Before the rule.', 'After the rule.']);
-  });
-
-  it('should return an empty array for empty string', () => {
-    expect(splitMarkdown('')).toEqual([]);
-  });
-
-  it('should merge short prose fragments', () => {
-    const text = 'Hi. This is a longer sentence here.';
-    const segments = splitMarkdown(text);
-    expect(segments).toEqual(['Hi. This is a longer sentence here.']);
-  });
-
-  it('should join multi-line prose into a single paragraph before splitting', () => {
-    const text =
-      'This is the first line of a paragraph.\nThis is the second line of the same paragraph.';
-    const segments = splitMarkdown(text);
-    // Should be joined and then split by Intl.Segmenter
-    expect(segments.length).toBeGreaterThanOrEqual(1);
-    expect(segments.join('')).toContain('first line');
-    expect(segments.join('')).toContain('second line');
-  });
-});