@eeacms/volto-eea-chatbot 2.0.1 → 2.0.3

package/src/ChatBlock/services/packetUtils.ts

@@ -1,5 +1,5 @@
-import type { Packet } from '../types/streamingModels';
-import { PacketType } from '../types/streamingModels';
+import type { Packet } from '@eeacms/volto-eea-chatbot/ChatBlock/types/streamingModels';
+import { PacketType } from '@eeacms/volto-eea-chatbot/ChatBlock/types/streamingModels';
 
 export function getSynteticPacket(ind: number, type: PacketType): Packet {
   return {
@@ -11,11 +11,15 @@ export function getSynteticPacket(ind: number, type: PacketType): Packet {
 export function isToolPacket(packet: Packet): boolean {
   const toolPacketTypes = [
     PacketType.SEARCH_TOOL_START,
+    PacketType.SEARCH_TOOL_START_V3,
+    PacketType.SEARCH_TOOL_QUERIES_DELTA,
+    PacketType.SEARCH_TOOL_DOCUMENTS_DELTA,
     PacketType.SEARCH_TOOL_DELTA,
     PacketType.CUSTOM_TOOL_START,
     PacketType.CUSTOM_TOOL_DELTA,
     PacketType.REASONING_START,
     PacketType.REASONING_DELTA,
+    PacketType.REASONING_DONE,
     PacketType.FETCH_TOOL_START,
   ];
 
@@ -40,9 +44,15 @@ export function isFinalAnswerComplete(packets: Packet[]): boolean {
     return false;
   }
 
-  return packets.some(
+  const hasSectionEnd = packets.some(
     (packet) =>
       packet.obj.type === PacketType.SECTION_END &&
       packet.ind === messageStartPacket.ind,
   );
+
+  if (hasSectionEnd) {
+    console.log(`[isFinalAnswerComplete] Complete! ind=${messageStartPacket.ind}`);
+  }
+
+  return hasSectionEnd;
 }

package/src/ChatBlock/services/streamingService.ts

@@ -1,5 +1,11 @@
-import { PacketType, type Packet } from '../types/streamingModels';
-import type { FileDescriptor, Filters } from '../types/interfaces';
+import {
+  PacketType,
+  type Packet,
+} from '@eeacms/volto-eea-chatbot/ChatBlock/types/streamingModels';
+import type {
+  FileDescriptor,
+  Filters,
+} from '@eeacms/volto-eea-chatbot/ChatBlock/types/interfaces';
 
 export interface SendMessageParams {
   regenerate: boolean;
@@ -24,6 +30,7 @@ export interface SendMessageParams {
   enabledToolIds?: number[];
   forcedToolIds?: number[];
   retrieval_options?: any;
+  onyxVersion?: '2' | '3';
 }
 
 export interface StreamResponse {
@@ -84,11 +91,131 @@ export const processRawChunkString = (
   return [parsedChunkSections, currPartialChunk];
 };
 
+// ─── Payload Templates ─────────────────────────────────────────────────────
+
+/**
+ * Build the Onyx 2.x send-message payload
+ */
+function buildPayloadV2(params: SendMessageParams): Record<string, unknown> {
+  const documentsAreSelected =
+    params.selectedDocumentIds && params.selectedDocumentIds.length > 0;
+
+  return {
+    alternate_assistant_id: params.alternateAssistantId,
+    chat_session_id: params.chatSessionId,
+    parent_message_id: params.parentMessageId,
+    message: params.message,
+    prompt_id: null,
+    search_doc_ids: documentsAreSelected ? params.selectedDocumentIds : null,
+    file_descriptors: params.fileDescriptors,
+    current_message_files: params.currentMessageFiles,
+    regenerate: params.regenerate,
+    retrieval_options:
+      params.retrieval_options ??
+      (!documentsAreSelected
+        ? {
+            run_search:
+              params.queryOverride || params.forceSearch ? 'always' : 'auto',
+            real_time: true,
+            filters: params.filters,
+          }
+        : null),
+    query_override: params.queryOverride,
+    prompt_override: {
+      ...(params.systemPromptOverride
+        ? { system_prompt: params.systemPromptOverride }
+        : {}),
+      ...(params.taskPromptOverride
+        ? { task_prompt: params.taskPromptOverride }
+        : {}),
+    },
+    llm_override:
+      params.temperature || params.modelVersion
+        ? {
+            temperature: params.temperature,
+            model_provider: params.modelProvider,
+            model_version: params.modelVersion,
+          }
+        : null,
+    use_existing_user_message: params.useExistingUserMessage,
+    use_agentic_search: params.useAgentSearch ?? false,
+    allowed_tool_ids: params.enabledToolIds,
+    forced_tool_ids: params.forcedToolIds,
+  };
+}
+
+/**
+ * Build the Onyx 3.x send-message payload
+ */
+function buildPayloadV3(params: SendMessageParams): Record<string, unknown> {
+  const payload = {
+    message: params.message,
+    chat_session_id: params.chatSessionId,
+    parent_message_id: params.parentMessageId,
+    file_descriptors: params.fileDescriptors ?? [],
+    internal_search_filters: {
+      source_type: params.filters?.source_type ?? ['web', 'github'],
+      document_set: params.filters?.document_set ?? null,
+      time_cutoff: params.filters?.time_cutoff ?? null,
+      tags: params.filters?.tags ?? [],
+    },
+    deep_research: params.useAgentSearch ?? false,
+    allowed_tool_ids: params.enabledToolIds?.length
+      ? params.enabledToolIds
+      : [1],
+    forced_tool_id: params.forcedToolIds?.[0] ?? null,
+    llm_override: {
+      temperature: params.temperature ?? 0.5,
+      model_provider:
+        params.modelProvider || 'Inhouse LiteLLM provider oss 120b',
+      model_version: params.modelVersion || 'Inhouse-LLM/gpt-oss-120b',
+    },
+    llm_overrides: null,
+    origin: 'webapp',
+    additional_context: null,
+    alternate_assistant_id: params.alternateAssistantId ?? null,
+    stream: true,
+  };
+  return payload;
+}
+
+/**
+ * Normalise a raw Onyx 3.x stream object into the canonical { ind, obj } Packet shape.
+ */
+function normaliseV3Chunk(raw: any): Packet | null {
+  // Bare identity packet (user/assistant message IDs – no placement wrapper)
+  if ('user_message_id' in raw && 'reserved_assistant_message_id' in raw) {
+    return {
+      ind: -1,
+      obj: {
+        type: PacketType.MESSAGE_END_ID_INFO,
+        user_message_id: raw.user_message_id,
+        reserved_assistant_message_id: raw.reserved_assistant_message_id,
+      },
+    } as Packet;
+  }
+
+  if (!raw.placement || typeof raw.obj !== 'object') return null;
+
+  const ind: number = raw.placement.turn_index ?? 0;
+  const obj = raw.obj;
+
+  // Map citation_number to citation_num for compatibility with CitationDelta consumers
+  if (obj.type === PacketType.CITATION_INFO && 'citation_number' in obj) {
+    obj.citation_num = obj.citation_number;
+  }
+
+  const normalised = { ind, obj } as Packet;
+  // console.log('[Onyx v3] Normalised packet:', normalised);
+  return normalised;
+}
+
 /**
  * Handle streaming response from the backend
  */
 export async function* handleStream(
   streamingResponse: Response,
+  onyxVersion: '2' | '3' = '2',
 ): AsyncGenerator<Packet[], void, unknown> {
   const reader = streamingResponse.body?.getReader();
   if (!reader) {
@@ -114,6 +241,10 @@ export async function* handleStream(
       previousPartialChunk,
     );
 
+    if (onyxVersion === '3' && completedChunks.length > 0) {
+      // console.log('[Onyx v3] Raw completed chunks:', completedChunks);
+    }
+
     if (!completedChunks.length && !partialChunk) {
       break;
     }
@@ -124,6 +255,10 @@ export async function* handleStream(
     const packets: Packet[] = completedChunks
       .filter((chunk) => chunk && typeof chunk === 'object')
       .map((chunk) => {
+        if (onyxVersion === '3') {
+          return normaliseV3Chunk(chunk);
+        }
+
         // Onyx v2 format: { ind: number, obj: { type: string, ... } }
         if ('ind' in chunk && 'obj' in chunk) {
           return chunk as Packet;
@@ -167,77 +302,24 @@ export async function* handleStream(
  * Send a message and stream the response
  */
 export async function* sendMessage(
-  {
-    regenerate,
-    retrieval_options,
-    message,
-    fileDescriptors,
-    currentMessageFiles,
-    parentMessageId,
-    chatSessionId,
-    filters,
-    selectedDocumentIds,
-    queryOverride,
-    forceSearch,
-    modelProvider,
-    modelVersion,
-    temperature,
-    systemPromptOverride,
-    taskPromptOverride,
-    useExistingUserMessage,
-    alternateAssistantId,
-    signal,
-    useAgentSearch,
-    enabledToolIds,
-    forcedToolIds,
-  }: SendMessageParams,
+  params: SendMessageParams,
   isRelatedQuestion: boolean = false,
 ): AsyncGenerator<Packet[], void, unknown> {
-  const documentsAreSelected =
-    selectedDocumentIds && selectedDocumentIds.length > 0;
+  const { onyxVersion = '2', signal } = params;
 
-  const payload = {
-    alternate_assistant_id: alternateAssistantId,
-    chat_session_id: chatSessionId,
-    parent_message_id: parentMessageId,
-    message,
-    prompt_id: null,
-    search_doc_ids: documentsAreSelected ? selectedDocumentIds : null,
-    file_descriptors: fileDescriptors,
-    current_message_files: currentMessageFiles,
-    regenerate,
-    retrieval_options:
-      retrieval_options ??
-      (!documentsAreSelected
-        ? {
-            run_search: queryOverride || forceSearch ? 'always' : 'auto',
-            real_time: true,
-            filters: filters,
-          }
-        : null),
-    query_override: queryOverride,
-    prompt_override: {
-      ...(systemPromptOverride ? { system_prompt: systemPromptOverride } : {}),
-      ...(taskPromptOverride ? { task_prompt: taskPromptOverride } : {}),
-    },
-    llm_override:
-      temperature || modelVersion
-        ? {
-            temperature,
-            model_provider: modelProvider,
-            model_version: modelVersion,
-          }
-        : null,
-    use_existing_user_message: useExistingUserMessage,
-    use_agentic_search: useAgentSearch ?? false,
-    allowed_tool_ids: enabledToolIds,
-    forced_tool_ids: forcedToolIds,
-  };
+  const payload =
+    onyxVersion === '3' ? buildPayloadV3(params) : buildPayloadV2(params);
 
   const body = JSON.stringify(payload);
 
   const middleware = isRelatedQuestion ? '_rq' : '_da';
-  const sendMessageResponse = await fetch(`/${middleware}/chat/send-message`, {
+  const endpoint =
+    onyxVersion === '3' ? 'send-chat-message' : 'send-message';
+
+  console.log(`[sendMessage] Target URL: /${middleware}/chat/${endpoint} (v${onyxVersion})`);
+  console.log(`[sendMessage] Payload:`, payload);
+
+  const sendMessageResponse = await fetch(`/${middleware}/chat/${endpoint}`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
@@ -252,7 +334,7 @@ export async function* sendMessage(
     throw new Error(`Failed to send message - ${errorMsg}`);
   }
 
-  yield* handleStream(sendMessageResponse);
+  yield* handleStream(sendMessageResponse, onyxVersion);
 }
 
 /**
@@ -261,8 +343,13 @@ export async function* sendMessage(
 export async function createChatSession(
   personaId: number,
   description?: string,
+  isRelatedQuestion: boolean = false,
 ): Promise<string> {
-  const response = await fetch('/_da/chat/create-chat-session', {
+  const middleware = isRelatedQuestion ? '_rq' : '_da';
+  const url = `/${middleware}/chat/create-chat-session`;
+  console.log(`[createChatSession] URL: ${url}`);
+
+  const response = await fetch(url, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',

package/src/ChatBlock/types/streamingModels.ts

@@ -51,6 +51,13 @@ export enum PacketType {
   MESSAGE_END_ID_INFO = 'message_end_id_info',
 
   ERROR = 'error',
+
+  // Onyx v3 replacements
+  SEARCH_TOOL_START_V3 = 'search_tool_start',
+  SEARCH_TOOL_QUERIES_DELTA = 'search_tool_queries_delta',
+  SEARCH_TOOL_DOCUMENTS_DELTA = 'search_tool_documents_delta',
+  CITATION_INFO = 'citation_info',
+  REASONING_DONE = 'reasoning_done',
 }
 
 // Basic Message Packets
@@ -174,12 +181,44 @@ export interface ErrorObj extends BaseObj {
   error: string;
 }
 
+// Onyx v3 Specific Packets
+export interface SearchToolStartV3 extends BaseObj {
+  type: PacketType.SEARCH_TOOL_START_V3;
+  is_internet_search?: boolean;
+}
+
+export interface SearchToolQueriesDelta extends BaseObj {
+  type: PacketType.SEARCH_TOOL_QUERIES_DELTA;
+  queries: string[];
+}
+
+export interface SearchToolDocumentsDelta extends BaseObj {
+  type: PacketType.SEARCH_TOOL_DOCUMENTS_DELTA;
+  documents: OnyxDocument[];
+}
+
+export interface CitationInfo extends BaseObj {
+  type: PacketType.CITATION_INFO;
+  citation_number: number;
+  document_id: string;
+}
+
+export interface ReasoningDone extends BaseObj {
+  type: PacketType.REASONING_DONE;
+}
+
 export type ChatObj = MessageStart | MessageDelta | MessageEnd;
 export type StopObj = Stop;
 export type SectionEndObj = SectionEnd;
 
 // Specific tool objects
-export type SearchToolObj = SearchToolStart | SearchToolDelta | SectionEnd;
+export type SearchToolObj =
+  | SearchToolStart
+  | SearchToolDelta
+  | SearchToolStartV3
+  | SearchToolQueriesDelta
+  | SearchToolDocumentsDelta
+  | SectionEnd;
 export type ImageGenerationToolObj =
   | ImageGenerationToolStart
   | ImageGenerationToolDelta
@@ -196,6 +235,7 @@ export type ReasoningObj =
   | ReasoningStart
   | ReasoningDelta
   | ReasoningEnd
+  | ReasoningDone
   | SectionEnd;
 export type CitationObj =
   | CitationStart
@@ -212,7 +252,12 @@ export type ObjTypes =
   | SectionEndObj
   | CitationObj
   | ErrorObj
-  | MessageEndIdInfo;
+  | MessageEndIdInfo
+  | SearchToolStartV3
+  | SearchToolQueriesDelta
+  | SearchToolDocumentsDelta
+  | CitationInfo
+  | ReasoningDone;
 
 // Packet wrapper for streaming objects
 export interface Packet {

package/src/ChatBlock/utils/citations.ts

@@ -1,4 +1,4 @@
-import type { Message } from '../types/interfaces';
+import type { Message } from '@eeacms/volto-eea-chatbot/ChatBlock/types/interfaces';
 
 /**
  * Regex to match citation markers like [1], [2], etc.

package/src/halloumi/filtering.test.js

@@ -1,4 +1,12 @@
-import { parseExcludeIndices } from './filtering';
+import fetch from 'node-fetch';
+
+import {
+  parseExcludeIndices,
+  callLLM,
+  excludeClaimSentences,
+  excludeContextSentences,
+} from './filtering';
+jest.mock('node-fetch');
 
 describe('parseExcludeIndices', () => {
   it('parses single indices', () => {
@@ -42,3 +50,193 @@ describe('parseExcludeIndices', () => {
     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());
+  });
+});

package/src/middleware.js

@@ -186,11 +186,21 @@ async function send_onyx_request(
     options.body = JSON.stringify(req.body);
   }
 
+  console.log('[Middleware] Sending request to Onyx:', {
+    url,
+    method: req.method,
+    hasBody: !!req.body,
+    body: JSON.stringify(req.body, null, 2),
+  });
+
   const mock_file = is_related_question
     ? process.env.MOCK_LLM_FILE_PATH_RQ
     : process.env.MOCK_LLM_FILE_PATH;
 
-  if (mock_file && req.url.endsWith('send-message')) {
+  if (
+    mock_file &&
+    (req.url.endsWith('send-message') || req.url.endsWith('send-chat-message'))
+  ) {
     try {
       await new Promise((resolve) => setTimeout(resolve, 2000));
       mock_send_message(res, is_related_question);
@@ -210,6 +220,13 @@ async function send_onyx_request(
     log(`Fetching ${url}`);
     const response = await fetch(url, options, req.body);
 
+    console.log('[Middleware] Received response from Onyx:', {
+      url,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers.raw(),
+    });
+
     if (process.env.DUMP_LLM_FILE_PATH && !is_related_question) {
       const filePath = process.env.DUMP_LLM_FILE_PATH;
       const writer = fs.createWriteStream(filePath);

package/src/middleware.test.js

@@ -18,6 +18,7 @@ jest.mock('node-fetch', () => {
     status: 200,
     headers: {
       get: jest.fn().mockReturnValue('application/json'),
+      raw: jest.fn().mockReturnValue({}),
     },
     body: { pipe: mockPipe },
   });
@@ -220,4 +221,17 @@ describe('src/middleware', () => {
 
     expect(res.write).toHaveBeenCalled();
   });
+
+  it('dumps LLM response when DUMP_LLM_FILE_PATH is set', async () => {
+    process.env.ONYX_API_KEY = 'test-key';
+    process.env.ONYX_URL = 'http://localhost:3000';
+    process.env.DUMP_LLM_FILE_PATH = '/tmp/dumped_response.jsonl';
+
+    await middleware(req, res, next);
+
+    const fs = require('fs');
+    expect(fs.createWriteStream).toHaveBeenCalledWith(
+      '/tmp/dumped_response.jsonl',
+    );
+  });
 });