@websolutespa/bom-mixer-llm 0.0.1

package/src/useLlm/message.service.ts

@@ -0,0 +1,336 @@
+import { isObject } from '@websolutespa/bom-core';
+import { LlmChunk, LlmChunkItem, LlmCredentials, LlmDecodedMessage, LlmMessage, StreamResponse } from '../types';
+
+export type MessageServiceRequest = LlmCredentials & {
+  messages: LlmMessage[];
+  test?: boolean;
+};
+
+export type MessageServiceResponse = {
+};
+
+export type MessageServiceOptions = {
+  url: string;
+};
+
+export class MessageService {
+
+  options: MessageServiceOptions;
+  private decoder_ = new TextDecoder('utf-8');
+
+  private lastMessage_: {
+    aborter: AbortController;
+    onEnd?: (response: StreamResponse) => void;
+    decodedChunks: LlmChunk[];
+    reader?: ReadableStreamDefaultReader<Uint8Array>;
+  } | undefined;
+
+  constructor(options: MessageServiceOptions) {
+    this.options = options;
+  }
+
+  async sendMessage(
+    request: MessageServiceRequest,
+    onMessage?: (response: StreamResponse) => void,
+    onEnd?: (response: StreamResponse) => void,
+    onChunk?: (chunks: LlmChunk[]) => void
+  ) {
+    this.abort();
+    // console.log('MessageServiceService.request', request);
+    const aborter = new AbortController();
+    const url = this.options.url;
+    const decodedChunks: LlmChunk[] = [];
+    this.lastMessage_ = {
+      aborter,
+      decodedChunks,
+      onEnd,
+    };
+    let bytes = 0;
+    const signal = aborter.signal;
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify(request),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        signal,
+      });
+      if (response.body) {
+        const reader = response.body.getReader();
+        this.lastMessage_.reader = reader;
+        for await (const chunk of readChunks(reader)) {
+          if (!signal.aborted) {
+            bytes += chunk.length;
+            const chunks = this.bytesToChunks(chunk);
+            decodedChunks.push(...chunks);
+            const response = chunksToResponse(decodedChunks);
+            if (typeof onMessage === 'function') {
+              onMessage(response);
+            }
+            if (typeof onChunk === 'function') {
+              onChunk(chunks);
+            }
+          }
+        }
+        if (!signal.aborted) {
+          if (typeof onEnd === 'function') {
+            const response = chunksToResponse(decodedChunks);
+            onEnd(response);
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof TypeError) {
+        console.error('TypeError: Browser may not support async iteration', error);
+      }
+      throw (error);
+    }
+  }
+
+  abort() {
+    const lastMessage = this.lastMessage_;
+    if (lastMessage && lastMessage.aborter && !lastMessage.aborter.signal.aborted) {
+      try {
+        if (lastMessage.reader) {
+          lastMessage.reader.cancel().catch((error) => {
+            console.log('MessageService.abort.reader.error', error);
+          });
+        }
+        lastMessage.aborter.abort();
+      } catch (error) {
+        console.log('MessageService.abort.error', error);
+      }
+      if (typeof lastMessage.onEnd === 'function') {
+        const response = chunksToResponse(lastMessage.decodedChunks);
+        lastMessage.onEnd(response);
+      }
+    }
+  }
+
+  bytesToChunks(byteArray: Uint8Array): LlmChunk[] {
+    let decodedChunks: LlmChunk[] = [];
+    let decodedText: string = '';
+    try {
+      decodedText = this.decoder_.decode(byteArray);
+      decodedChunks = textToChunks(decodedText);
+    } catch (error) {
+      console.log('decodedChunk.error', error, decodedText);
+    }
+    // console.log(decodedChunks, decodedText);
+    return decodedChunks;
+  }
+
+}
+
+function readChunks<T>(reader: ReadableStreamDefaultReader<T>) {
+  return {
+    async*[Symbol.asyncIterator]() {
+      let readResult = await reader.read();
+      while (!readResult.done) {
+        yield readResult.value;
+        readResult = await reader.read();
+      }
+    },
+  };
+}
+
+/*
+async function* streamAsyncIterable<T>(stream: ReadableStream<T>) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+class Iterator {
+}
+
+(Iterator as any).prototype[Symbol.asyncIterator] = async function* () {
+  const reader = this.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  }
+  finally {
+    reader.releaseLock();
+  }
+};
+*/
+
+export function chunksToResponse(decodedChunks: LlmChunk[]): StreamResponse {
+  const response: StreamResponse = {
+    chunks: [],
+    threadId: '',
+  };
+  response.chunks = chunksToChunkItems(decodedChunks, response);
+  return response;
+}
+
+export function textToChunks(decodedText: string): LlmChunk[] {
+  let decodedChunks: LlmChunk[] = [];
+  try {
+    // const replacedText = decodedText.replace(/(^\[)|(,$)|(\]$)/g, '');
+    let replacedText = decodedText;
+    // replacedText = replacedText.replace(/(^,")/, '",');
+    replacedText = replacedText.replace(/(,$)/, '');
+    // replacedText = replacedText.replace(/}\s{/g, '},{');
+    /*
+    replacedText = replacedText.split(',').map(x => {
+      return x.replace(/^"([^{]*)"$/m, (m, g) => {
+        return '"' + g.replace('"', '\\"') + '"';
+      });
+    }).join(',');
+    */
+    // console.log('textToChunks.replacedText', `[${replacedText}]`);
+    const chunks: LlmChunk[] = JSON.parse(`[${replacedText}]`);
+    // console.log('chunks', chunks);
+    /*
+    decodedChunks = chunks.map(chunk => {
+      if (typeof chunk === 'string') {
+        chunk = chunk.replace(/\r\n/g, '<br>');
+      }
+      return chunk;
+    });
+    */
+    decodedChunks = chunks;
+  } catch (error) {
+    console.log('textToChunks.error', error, decodedText);
+  }
+  // console.log(decodedChunks, decodedText);
+  return decodedChunks;
+}
+
+export function chunksToChunkItems(decodedChunks: LlmChunk[], response?: StreamResponse): LlmChunkItem[] {
+  const chunks: LlmChunkItem[] = [];
+  decodedChunks.forEach(x => {
+    const lastMessage = chunks[chunks.length - 1];
+    if (isObject(x)) {
+      switch (x.type) {
+        case 'log':
+          console.log('LlmMessageService.log', x);
+          break;
+        case 'error':
+          console.error('LlmMessageService.error', x);
+          break;
+        case 'info':
+        case 'end': {
+          const { type, ...rest } = x;
+          if (response) {
+            Object.assign(response, rest);
+          }
+          // response = { ...response, ...rest };
+        }
+          break;
+        case 'eventItem':
+          if (lastMessage && lastMessage.type === 'eventGroup') {
+            lastMessage.items.push(x);
+          } else {
+            chunks.push({
+              type: 'eventGroup',
+              items: [x],
+            });
+          }
+          break;
+        case 'poiItem':
+          if (lastMessage && lastMessage.type === 'poiGroup') {
+            lastMessage.items.push(x);
+          } else {
+            chunks.push({
+              type: 'poiGroup',
+              items: [x],
+            });
+          }
+          break;
+        case 'tripadvisor':
+        case 'tripadvisorItem':
+          if (lastMessage && lastMessage.type === 'tripadvisorGroup') {
+            lastMessage.items.push({ ...x, type: 'tripadvisorItem' });
+          } else {
+            chunks.push({
+              type: 'tripadvisorGroup',
+              items: [{ ...x, type: 'tripadvisorItem' }],
+            });
+          }
+          break;
+        default:
+          chunks.push(x);
+      }
+    } else if (typeof x === 'string') {
+      // console.warn('chunksToChunkItems typeof string');
+      if (lastMessage && lastMessage.type === 'string' && !lastMessage.content.includes('\n')) {
+        if (x.includes('\n')) {
+          const contents = x.split('\n');
+          contents.forEach((content, i) => {
+            const lastChar = (contents.length > i + 1) ? '\n' : '';
+            if (i === 0) {
+              lastMessage.content += content + lastChar;
+            } else if (content.length > 0) {
+              chunks.push({
+                type: 'string',
+                content: content + lastChar,
+              });
+            }
+          });
+        } else {
+          lastMessage.content += x;
+        }
+      } else {
+        chunks.push({
+          type: 'string',
+          content: x,
+        });
+      }
+    }
+  });
+  return chunks;
+}
+
+export function decodeMessages(messages: LlmMessage[]): LlmDecodedMessage[] {
+  return messages.map(x => {
+    if (x.role === 'user') {
+      return ({
+        ...x,
+        chunks: [{
+          type: 'string',
+          content: x.content,
+        }],
+      });
+    }
+    return ({
+      ...x,
+      chunks: chunksToChunkItems(textToChunks(x.content)),
+      /*
+      chunks: chunksToChunkItems(textToChunks(
+        x.content
+          .split('\r\n')
+          .map(x => {
+            if (['{', '['].includes(x.substring(0, 1))) {
+              // console.log('obj', x);
+              return x;
+            } else {
+              // console.log('str', `"${x.replace(/\n/g, '\\n')}"`);
+              return `"${x.replace(/\n/g, '\\n')}"`;
+            }
+          })
+          .join(',')
+      )),
+      */
+    });
+  });
+}
+
+export function shouldAddFormRequest(messages: LlmDecodedMessage[]): boolean {
+  const hasFormRequest = messages.find(x => x.chunks.find(x => x.type === 'formRequest') !== undefined);
+  const importantMessages = messages.filter(x => x.chunks.find(x => ['event', 'eventItem', 'eventGroup', 'poi', 'poiItem', 'poiGroup', 'tripadvisor', 'tripadvisorItem', 'tripadvisorGroup'].includes(x.type)) !== undefined);
+  return !hasFormRequest && importantMessages.length > 1;
+}