@liip/liipgpt 0.0.24 → 1.0.0-rc.1

package/lib/chat-message-types.d.ts

@@ -1,42 +1,53 @@
-import { Sources } from '../../../../../src/lib/liipgpt-client';
-export type ChatMessageBot = {
+import { ServerError } from '../../../../../src/lib/sse-v2-types';
+export type Reference = {
+    url: string;
+    referencesIndex: {
+        all: number;
+        used?: number;
+    };
+    considered: boolean;
+    display: {
+        card: {
+            title?: string;
+            description?: string;
+            badge?: string;
+            breadcrumb?: string[];
+        };
+        listItem: {
+            title?: string;
+            description?: string;
+            badge?: string;
+            breadcrumb?: string[];
+        };
+    };
+};
+export type References = {
+    all: Reference[];
+    used: Reference[];
+};
+export type ChatMessageBotStreaming = {
     type: 'bot';
     /**
      * ISO Timestamp
      */
     time: string;
     id: string;
+    state: 'streaming' | 'done';
     message: {
         markdown: string;
         html: string;
     };
-    partial: boolean;
-    sources: Sources;
-};
-type ChatMessageLoading = {
-    type: 'bot-loading';
-    /**
-     * ISO Timestamp
-     */
-    time: string;
+    references: References;
+    errors: ChatErrors[];
 };
-type ChatMessageError = {
-    type: 'bot-error';
-    /**
-     * ISO Timestamp
-     */
-    time: string;
-    id: string;
-    message: string;
-};
-type ChatMessageUser = {
-    type: 'user';
-    /**
-     * ISO Timestamp
-     */
-    time: string;
-    message: string;
-    betterQuestion?: string;
+export type ChatMessageBotLoading = Omit<ChatMessageBotStreaming, 'id' | 'state'> & {
+    id?: string;
+    state: 'loading';
 };
-export type ChatMessage = ChatMessageBot | ChatMessageUser | ChatMessageLoading | ChatMessageError;
-export {};
+export type ChatMessageBotRaw = ChatMessageBotLoading | ChatMessageBotStreaming;
+export type ChatMessageBot = ChatMessageBotRaw | (Omit<ChatMessageBotRaw, 'id'> & {
+    id: undefined;
+    incomplete: true;
+});
+export type ChatErrors = ServerError | 'sse-error' | 'client-error' | 'unexpected-call' | 'incomplete-error';
+export type OnError = (error: ChatErrors) => void;

package/lib/liipgpt-client.d.ts

@@ -1,10 +1,12 @@
 import { ClassificationConfig, MenuItem, PredefinedQuestion } from '../../../../../src/lib/types';
 import { Readable } from 'svelte/store';
-import { ChatMessageBot } from './chat-message-types';
+import { Constructor } from 'type-fest';
+import { ChatMessageBot, OnError } from './chat-message-types';
 type LiipGPTClientOptions = {
     apiUrl: string;
     apiKey?: string;
     strict?: boolean;
+    EventSource?: Constructor<EventSource>;
 };
 export type Language = 'en' | 'de' | 'fr' | 'it';
 export type ReferenceData = {
@@ -30,19 +32,12 @@ type MenuParams = {
     url: string;
     language: string;
 };
-type ChatResponse = {
-    state: 'loading';
-} | {
-    state: 'error';
-    errorMessage?: string;
-} | {
-    state: 'streaming' | 'done';
-    payload: ChatMessageBot;
-};
 export type ChatOptions = {
     model?: string;
     lang?: string;
     modes?: string[];
+    version?: string;
+    onError?: OnError;
 };
 export type QuickFeedbackType = 'positive' | 'negative';
 export type QuickFeedback = {
@@ -72,10 +67,11 @@ export declare class LiipGPTClient {
     private readonly apiUrl;
     private readonly apiKey;
     private readonly strict;
+    private readonly EventSource;
     lastRequestId: string | undefined;
     private idToQuestionsMap;
     metadata: Promise<ClientMetadata>;
-    constructor({ apiUrl, apiKey, strict }: LiipGPTClientOptions);
+    constructor({ apiUrl, apiKey, strict, EventSource: EventSourceOption }: LiipGPTClientOptions);
     private getUserData;
     static getInstance(): LiipGPTClient | undefined;
     private postData;
@@ -90,8 +86,7 @@ export declare class LiipGPTClient {
     getMenu(params: MenuParams): Promise<MenuItem[]>;
     getUsedLanguages(): Promise<Language[]>;
     private chatInternal;
-    chat(message: string, options?: ChatOptions): Readable<ChatResponse>;
-    search(query: string, options?: ChatOptions): Readable<ChatResponse>;
-    private transformURL;
+    chat(message: string, options?: ChatOptions): Readable<ChatMessageBot>;
+    search(query: string, options?: ChatOptions): Readable<ChatMessageBot>;
 }
 export {};