@eeacms/volto-eea-chatbot 3.0.1 → 4.0.0

package/src/halloumi/middleware.test.js

@@ -1,19 +1,25 @@
-import middleware from './middleware';
+import fetch from 'node-fetch';
 import { isPathAllowed } from '../middleware';
 
-jest.mock('./generative');
+// Mock node-fetch
+jest.mock('node-fetch');
 
 describe('halloumi middleware', () => {
-  let req, res, next;
+  let req, res, next, middleware;
 
   beforeEach(() => {
+    fetch.mockReset();
+    // Clear the module cache so middleware is re-imported with current env vars
+    jest.resetModules();
+    // Re-mock after reset
+    jest.mock('node-fetch', () => jest.fn());
+
     req = {
       url: '/_ha/generate',
       method: 'POST',
       body: {
         sources: ['source1', 'source2'],
         answer: 'test answer',
-        maxContextSegments: 3,
       },
       headers: {},
       ip: '127.0.0.1',
@@ -30,23 +36,90 @@ describe('halloumi middleware', () => {
     jest.restoreAllMocks();
   });
 
-  it('returns error when LLMGW_TOKEN is missing', async () => {
-    const origToken = process.env.LLMGW_TOKEN;
-    const origUrl = process.env.LLMGW_URL;
-    delete process.env.LLMGW_TOKEN;
-    delete process.env.LLMGW_URL;
+  it('proxies request to rag-fact-checker and returns response', async () => {
+    process.env.RAG_FACT_CHECKER_URL = 'http://localhost:8000';
+    middleware = require('./middleware').default;
+    const mockedFetch = require('node-fetch');
+
+    const mockResponse = {
+      claims: [
+        {
+          startOffset: 0,
+          endOffset: 20,
+          segmentIds: ['0'],
+          score: 0.95,
+          rationale: 'Supported by source.',
+        },
+      ],
+      segments: { 0: { startOffset: 0, endOffset: 30 } },
+    };
+
+    mockedFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    await middleware(req, res, next);
+
+    expect(mockedFetch).toHaveBeenCalledWith(
+      'http://localhost:8000/halloumi/generate',
+      expect.objectContaining({
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          answer: 'test answer',
+          sources: ['source1', 'source2'],
+          max_context_segments: 0,
+        }),
+      }),
+    );
+    expect(res.set).toHaveBeenCalledWith('Content-Type', 'application/json');
+    expect(res.send).toHaveBeenCalledWith(mockResponse);
+  });
+
+  it('returns 502 when rag-fact-checker is unreachable', async () => {
+    process.env.RAG_FACT_CHECKER_URL = 'http://localhost:8000';
+    middleware = require('./middleware').default;
+    const mockedFetch = require('node-fetch');
+
+    mockedFetch.mockRejectedValue(new Error('ECONNREFUSED'));
 
     await middleware(req, res, next);
 
-    expect(res.send).toHaveBeenCalledWith({
-      error: 'Invalid configuration: missing LLMGW_TOKEN or LLMGW_URL',
+    expect(res.status).toHaveBeenCalledWith(502);
+    expect(res.send).toHaveBeenCalledWith(
+      expect.objectContaining({
+        error: expect.stringContaining('Fact-checker unavailable'),
+      }),
+    );
+  });
+
+  it('returns error when rag-fact-checker responds with non-ok status', async () => {
+    process.env.RAG_FACT_CHECKER_URL = 'http://localhost:8000';
+    middleware = require('./middleware').default;
+    const mockedFetch = require('node-fetch');
+
+    mockedFetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      json: () => Promise.resolve({ detail: 'Internal server error' }),
     });
 
-    process.env.LLMGW_TOKEN = origToken; //betterleaks:allow
-    process.env.LLMGW_URL = origUrl;
+    await middleware(req, res, next);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.send).toHaveBeenCalledWith(
+      expect.objectContaining({
+        error: expect.stringContaining('Internal server error'),
+      }),
+    );
   });
 
   it('rejects disallowed paths with 404', async () => {
+    process.env.RAG_FACT_CHECKER_URL = 'http://localhost:8000';
+    middleware = require('./middleware').default;
+
     req.url = '/_ha/admin/config';
     req.method = 'POST';
 
@@ -57,6 +130,9 @@ describe('halloumi middleware', () => {
   });
 
   it('rejects allowed path with wrong HTTP method', async () => {
+    process.env.RAG_FACT_CHECKER_URL = 'http://localhost:8000';
+    middleware = require('./middleware').default;
+
     req.url = '/_ha/generate';
     req.method = 'GET';
 
@@ -65,100 +141,29 @@ describe('halloumi middleware', () => {
     expect(res.statusCode).toBe(404);
     expect(res.send).toHaveBeenCalledWith({ error: 'Not Found' });
   });
-});
-
-// These tests need a fresh module loaded with env vars set so that
-// LLMGW_TOKEN and LLMGW_URL are defined at module load time,
-// allowing the code to reach getVerifyClaimResponse.
-describe('halloumi middleware - dynamic import', () => {
-  const buildReq = () => ({
-    url: '/_ha/generate',
-    method: 'POST',
-    body: {
-      sources: ['source1', 'source2'],
-      answer: 'test answer',
-      maxContextSegments: 3,
-    },
-    headers: {},
-    ip: '127.0.0.1',
-  });
 
-  const buildRes = () => ({
-    send: jest.fn(),
-    set: jest.fn(),
-    status: jest.fn().mockReturnThis(),
-  });
-
-  it('sends response on successful getVerifyClaimResponse', async () => {
-    const origToken = process.env.LLMGW_TOKEN;
-    const origUrl = process.env.LLMGW_URL;
-    process.env.LLMGW_TOKEN = 'test-token'; //betterleaks:allow
-    process.env.LLMGW_URL = 'http://test-url';
-
-    jest.resetModules();
-
-    const mockGetVerifyClaimResponse = jest
-      .fn()
-      .mockResolvedValue({ claims: [], segments: {} });
-
-    jest.setMock('./generative', {
-      getVerifyClaimResponse: mockGetVerifyClaimResponse,
-    });
-
-    const middlewareMod = require('./middleware').default;
-
-    const req = buildReq();
-    const res = buildRes();
-
-    await middlewareMod(req, res, jest.fn());
-
-    expect(mockGetVerifyClaimResponse).toHaveBeenCalled();
-    expect(res.set).toHaveBeenCalledWith('Content-Type', 'application/json');
-    expect(res.send).toHaveBeenCalledWith({ claims: [], segments: {} });
-
-    process.env.LLMGW_TOKEN = origToken; //betterleaks:allow
-    process.env.LLMGW_URL = origUrl;
-  });
+  it('uses default URL when RAG_FACT_CHECKER_URL is not set', async () => {
+    delete process.env.RAG_FACT_CHECKER_URL;
+    middleware = require('./middleware').default;
+    const mockedFetch = require('node-fetch');
 
-  it('handles errors from getVerifyClaimResponse', async () => {
-    const origToken = process.env.LLMGW_TOKEN;
-    const origUrl = process.env.LLMGW_URL;
-    process.env.LLMGW_TOKEN = 'test-token'; //betterleaks:allow
-    process.env.LLMGW_URL = 'http://test-url';
-
-    jest.resetModules();
-
-    const mockGetVerifyClaimResponse = jest
-      .fn()
-      .mockRejectedValue(new Error('LLM error'));
-
-    jest.setMock('./generative', {
-      getVerifyClaimResponse: mockGetVerifyClaimResponse,
+    mockedFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ claims: [], segments: {} }),
     });
 
-    const middlewareMod = require('./middleware').default;
-
-    const req = buildReq();
-    const res = buildRes();
-
-    await middlewareMod(req, res, jest.fn());
+    await middleware(req, res, next);
 
-    expect(res.status).toHaveBeenCalledWith(500);
-    expect(res.send).toHaveBeenCalledWith(
-      expect.objectContaining({ error: expect.stringContaining('LLM error') }),
+    expect(mockedFetch).toHaveBeenCalledWith(
+      'http://localhost:8000/halloumi/generate',
+      expect.any(Object),
     );
-
-    process.env.LLMGW_TOKEN = origToken; //betterleaks:allow
-    process.env.LLMGW_URL = origUrl;
   });
 });
 
 describe('halloumi path allowlist', () => {
-  // Mirror of ALLOWED_HALLOUMI_PATHS from middleware.js
-  const ALLOWED_HALLOUMI_PATHS = [
-    { path: '/generate', methods: ['POST'] },
-    { path: '/classify', methods: ['POST'] },
-  ];
+  const ALLOWED_HALLOUMI_PATHS = [{ path: '/generate', methods: ['POST'] }];
 
   it('allows /generate with POST', () => {
     expect(isPathAllowed('/generate', 'POST', ALLOWED_HALLOUMI_PATHS)).toBe(
@@ -166,12 +171,6 @@ describe('halloumi path allowlist', () => {
     );
   });
 
-  it('allows /classify with POST', () => {
-    expect(isPathAllowed('/classify', 'POST', ALLOWED_HALLOUMI_PATHS)).toBe(
-      true,
-    );
-  });
-
   it('rejects /generate with wrong method', () => {
     expect(isPathAllowed('/generate', 'GET', ALLOWED_HALLOUMI_PATHS)).toBe(
       false,

package/src/halloumi/filtering.js

@@ -1,149 +0,0 @@
-import debug from 'debug';
-import fetch from 'node-fetch';
-
-const log = debug('halloumi');
-
-const LLMGW_URL = process.env.LLMGW_URL;
-const LLMGW_API_KEY = process.env.LLMGW_TOKEN; //betterleaks:allow
-const MIN_CONTEXT_SENTENCES_FOR_FILTERING = 75;
-
-const filterModel = {
-  name: 'Inhouse-LLM/gpt-oss-120b',
-  apiUrl: `${LLMGW_URL}/chat/completions`,
-  apiKey: LLMGW_API_KEY, //betterleaks:allow
-};
-
-export async function callLLM(apiUrl, apiKey, requestBody, { ip } = {}) {
-  const headers = {
-    'Content-Type': 'application/json',
-    accept: 'application/json',
-  };
-  if (apiKey) {
-    headers['Authorization'] = `Bearer ${apiKey}`;
-  }
-  if (ip) {
-    headers['X-Forwarded-For'] = ip;
-  }
-
-  const response = await fetch(apiUrl, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(requestBody),
-  });
-
-  return response.json();
-}
-
-function buildClaimFilterPrompt(sentences) {
-  const numberedSentences = sentences
-    .map((s, i) => `${i + 1}. "${s.trim()}"`)
-    .join('\n');
-
-  return `Given the following numbered sentences, identify which ones are NOT verifiable factual claims.
-
-Exclude sentences that are:
-- Greetings, preambles, or transitional phrases
-- Opinions, vague statements, or subjective assessments
-- Introductory sentences that set up a list or table
-- Sentences that merely restate or paraphrase the question
-- Conversational closers (e.g., "let me know if you need more")
-- Broad summaries that don't assert a specific fact
-- Disclaimers or meta-commentary about the response itself
-- Sentences that do not provide enough information to verify
-- Sentences that only mention a concept without providing specific information
-
-Respond with ONLY a comma-separated list of the sentence numbers to exclude. If none should be excluded, respond with "NONE".
-
-Sentences:
-${numberedSentences}`;
-}
-
-function buildContextFilterPrompt(contextSentences, claimSentences) {
-  const numberedContext = contextSentences
-    .map((s, i) => `${i + 1}. "${s.trim()}"`)
-    .join('\n');
-  const numberedClaims = claimSentences
-    .map((s, i) => `${i + 1}. "${s.trim()}"`)
-    .join('\n');
-
-  return `Given the following context sentences and claims, identify which context sentences are NOT relevant to verifying ANY of the claims.
-
-Context sentences:
-${numberedContext}
-
-Claims to verify:
-${numberedClaims}
-
-Respond with ONLY a comma-separated list of the context sentence numbers that are NOT relevant. If all are relevant, respond with "NONE".`;
-}
-
-/**
- * Parses a comma-separated list of indices from an LLM response.
- */
-export function parseExcludeIndices(content, maxIndex) {
-  const excludeIndices = new Set();
-  if (content.trim().toUpperCase() === 'NONE') {
-    return excludeIndices;
-  }
-  const matches = content.match(/\d+/g) || [];
-  for (const match of matches) {
-    const idx = parseInt(match, 10);
-    if (idx >= 1 && idx <= maxIndex) {
-      excludeIndices.add(idx);
-    }
-  }
-  return excludeIndices;
-}
-
-async function callFilterModel(prompt, { ip } = {}) {
-  const data = {
-    messages: [{ role: 'user', content: prompt }],
-    temperature: 0.0,
-    model: filterModel.name,
-  };
-  const jsonData = await callLLM(filterModel.apiUrl, filterModel.apiKey, data, {
-    ip,
-  });
-  return jsonData.choices?.[0]?.message?.content || '';
-}
-
-export async function excludeClaimSentences(sentences, { ip } = {}) {
-  if (sentences.length === 0) {
-    return new Set();
-  }
-
-  try {
-    const prompt = buildClaimFilterPrompt(sentences);
-    const content = await callFilterModel(prompt, { ip });
-    const excludedIndices = parseExcludeIndices(content, sentences.length);
-    log('Claim filter response', excludedIndices.size);
-    return excludedIndices;
-  } catch (error) {
-    log('Claim filter failed, skipping', error);
-    return new Set();
-  }
-}
-
-export async function excludeContextSentences(
-  contextSentences,
-  claimSentences,
-  { ip } = {},
-) {
-  if (contextSentences.length <= MIN_CONTEXT_SENTENCES_FOR_FILTERING) {
-    return new Set();
-  }
-
-  try {
-    const prompt = buildContextFilterPrompt(contextSentences, claimSentences);
-    const content = await callFilterModel(prompt, { ip });
-    const excludedIndices = parseExcludeIndices(
-      content,
-      contextSentences.length,
-    );
-    log('Context filter response', excludedIndices.size);
-    return excludedIndices;
-  } catch (error) {
-    log('Context filter failed, skipping', error);
-    return new Set();
-  }
-}

package/src/halloumi/filtering.test.js

@@ -1,242 +0,0 @@
-import fetch from 'node-fetch';
-
-import {
-  parseExcludeIndices,
-  callLLM,
-  excludeClaimSentences,
-  excludeContextSentences,
-} from './filtering';
-jest.mock('node-fetch');
-
-describe('parseExcludeIndices', () => {
-  it('parses single indices', () => {
-    const result = parseExcludeIndices('1,3,5', 6);
-    expect(result).toEqual(new Set([1, 3, 5]));
-  });
-
-  it('returns empty set for NONE', () => {
-    const result = parseExcludeIndices('NONE', 10);
-    expect(result).toEqual(new Set());
-  });
-
-  it('returns empty set for none (lowercase)', () => {
-    const result = parseExcludeIndices('  none  ', 10);
-    expect(result).toEqual(new Set());
-  });
-
-  it('ignores indices below 1', () => {
-    const result = parseExcludeIndices('0, 1, 3', 5);
-    expect(result).toEqual(new Set([1, 3]));
-  });
-
-  it('ignores indices above maxIndex', () => {
-    const result = parseExcludeIndices('1, 3, 99', 5);
-    expect(result).toEqual(new Set([1, 3]));
-  });
-
-  it('handles whitespace variations', () => {
-    const result = parseExcludeIndices('  1 ,  5 , 7  ', 10);
-    expect(result).toEqual(new Set([1, 5, 7]));
-  });
-
-  it('extracts numbers even from unexpected formats', () => {
-    // Parser uses match(/\d+/g) so it extracts all numbers
-    const result = parseExcludeIndices('1-3, 5', 10);
-    expect(result).toEqual(new Set([1, 3, 5]));
-  });
-
-  it('returns empty set for empty string with no numbers', () => {
-    const result = parseExcludeIndices('no numbers here', 10);
-    expect(result).toEqual(new Set());
-  });
-});
-
-describe('callLLM', () => {
-  beforeEach(() => {
-    fetch.mockReset();
-  });
-
-  afterEach(() => {
-    fetch.mockReset();
-  });
-
-  it('makes POST request with correct headers', async () => {
-    const mockResponse = { choices: [{ message: { content: 'result' } }] };
-    fetch.mockResolvedValue({
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    await callLLM('https://api.example.com', 'my-api-key', { model: 'gpt-4' });
-
-    expect(fetch).toHaveBeenCalledWith(
-      'https://api.example.com',
-      expect.objectContaining({
-        method: 'POST',
-        headers: expect.objectContaining({
-          'Content-Type': 'application/json',
-          Authorization: 'Bearer my-api-key',
-        }),
-      }),
-    );
-  });
-
-  it('omits Authorization header when no apiKey', async () => {
-    fetch.mockResolvedValue({
-      json: () => Promise.resolve({}),
-    });
-
-    await callLLM('https://api.example.com', null, { model: 'gpt-4' });
-
-    const headers = fetch.mock.calls[0][1].headers;
-    expect(headers['Authorization']).toBeUndefined();
-  });
-
-  it('adds X-Forwarded-For header when ip is provided', async () => {
-    fetch.mockResolvedValue({
-      json: () => Promise.resolve({}),
-    });
-
-    await callLLM('https://api.example.com', null, {}, { ip: '1.2.3.4' });
-
-    const headers = fetch.mock.calls[0][1].headers;
-    expect(headers['X-Forwarded-For']).toBe('1.2.3.4');
-  });
-
-  it('returns parsed JSON response', async () => {
-    const mockResponse = { choices: [{ message: { content: 'hello' } }] };
-    fetch.mockResolvedValue({
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const result = await callLLM('https://api.example.com', null, {});
-    expect(result).toEqual(mockResponse);
-  });
-});
-
-describe('excludeClaimSentences', () => {
-  beforeEach(() => {
-    fetch.mockReset();
-  });
-
-  afterEach(() => {
-    fetch.mockReset();
-  });
-
-  it('returns empty set for empty sentences array', async () => {
-    const result = await excludeClaimSentences([]);
-    expect(result).toEqual(new Set());
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('calls LLM and returns excluded sentence indices', async () => {
-    fetch.mockResolvedValue({
-      json: () =>
-        Promise.resolve({
-          choices: [{ message: { content: '1,3' } }],
-        }),
-    });
-
-    const sentences = ['Sentence one.', 'Sentence two.', 'Sentence three.'];
-    const result = await excludeClaimSentences(sentences);
-
-    expect(result).toEqual(new Set([1, 3]));
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns empty set when LLM returns NONE', async () => {
-    fetch.mockResolvedValue({
-      json: () =>
-        Promise.resolve({
-          choices: [{ message: { content: 'NONE' } }],
-        }),
-    });
-
-    const sentences = ['Some factual sentence.', 'Another factual sentence.'];
-    const result = await excludeClaimSentences(sentences);
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('returns empty set on LLM error', async () => {
-    fetch.mockRejectedValue(new Error('Network error'));
-
-    const sentences = ['Sentence one.'];
-    const result = await excludeClaimSentences(sentences);
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('passes ip option to LLM call', async () => {
-    fetch.mockResolvedValue({
-      json: () =>
-        Promise.resolve({ choices: [{ message: { content: 'NONE' } }] }),
-    });
-
-    await excludeClaimSentences(['test sentence'], { ip: '10.0.0.1' });
-
-    const headers = fetch.mock.calls[0][1].headers;
-    expect(headers['X-Forwarded-For']).toBe('10.0.0.1');
-  });
-});
-
-describe('excludeContextSentences', () => {
-  const MIN_SENTENCES = 75;
-
-  beforeEach(() => {
-    fetch.mockReset();
-  });
-
-  afterEach(() => {
-    fetch.mockReset();
-  });
-
-  it('returns empty set when context sentences <= minimum threshold', async () => {
-    const shortContext = Array(10).fill('Short sentence.');
-    const claims = ['A claim.'];
-    const result = await excludeContextSentences(shortContext, claims);
-
-    expect(result).toEqual(new Set());
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it('calls LLM when context exceeds minimum threshold', async () => {
-    fetch.mockResolvedValue({
-      json: () =>
-        Promise.resolve({
-          choices: [{ message: { content: '1,2' } }],
-        }),
-    });
-
-    const longContext = Array(MIN_SENTENCES + 1).fill('Context sentence.');
-    const claims = ['A claim.'];
-    const result = await excludeContextSentences(longContext, claims);
-
-    expect(result).toEqual(new Set([1, 2]));
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns empty set on LLM error', async () => {
-    fetch.mockRejectedValue(new Error('timeout'));
-
-    const longContext = Array(MIN_SENTENCES + 1).fill('Context sentence.');
-    const claims = ['A claim.'];
-    const result = await excludeContextSentences(longContext, claims);
-
-    expect(result).toEqual(new Set());
-  });
-
-  it('returns empty set when LLM returns NONE for context', async () => {
-    fetch.mockResolvedValue({
-      json: () =>
-        Promise.resolve({
-          choices: [{ message: { content: 'NONE' } }],
-        }),
-    });
-
-    const longContext = Array(MIN_SENTENCES + 1).fill('Context sentence.');
-    const claims = ['A claim.'];
-    const result = await excludeContextSentences(longContext, claims);
-
-    expect(result).toEqual(new Set());
-  });
-});