@liip/liipgpt 2.3.4 → 2.4.0

package/index.d.ts

@@ -2,6 +2,7 @@
 
 import { WindowLike } from 'dompurify';
 import { MarkedExtension } from 'marked';
+import { SSE } from 'sse.js';
 
 export interface UsedLink {
 	url: string;
@@ -6636,6 +6637,12 @@ export declare const completeChatConfigSchema: z.ZodObject<{
 	renderKatex: z.ZodOptional<z.ZodBoolean>;
 	/** When set, changing the language will change the url path to /[selected language locale] */
 	reflectLanguageInPath: z.ZodOptional<z.ZodBoolean>;
+	/** When enabled, sends the current page referrer and domain to the backend with each question */
+	sendReferrer: z.ZodOptional<z.ZodEnum<[
+		"all",
+		"own",
+		"none"
+	]>>;
 }, "strip", z.ZodTypeAny, {
 	showPredefinedQuestions: boolean;
 	showOverallFeedbackButton: boolean;
@@ -7087,6 +7094,7 @@ export declare const completeChatConfigSchema: z.ZodObject<{
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }, {
 	showPredefinedQuestions: boolean;
 	showOverallFeedbackButton: boolean;
@@ -7538,6 +7546,7 @@ export declare const completeChatConfigSchema: z.ZodObject<{
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }>;
 export declare const chatConfigSchema: z.ZodObject<{
 	showPredefinedQuestions: z.ZodOptional<z.ZodBoolean>;
@@ -11919,6 +11928,11 @@ export declare const chatConfigSchema: z.ZodObject<{
 	addQueryToUrlParams: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
 	renderKatex: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
 	reflectLanguageInPath: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+	sendReferrer: z.ZodOptional<z.ZodOptional<z.ZodEnum<[
+		"all",
+		"own",
+		"none"
+	]>>>;
 }, "strip", z.ZodTypeAny, {
 	menu?: Partial<Record<"en" | "de" | "fr" | "it", {
 		url: string;
@@ -12370,6 +12384,7 @@ export declare const chatConfigSchema: z.ZodObject<{
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }, {
 	menu?: Partial<Record<"en" | "de" | "fr" | "it", {
 		url: string;
@@ -12821,6 +12836,7 @@ export declare const chatConfigSchema: z.ZodObject<{
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }>;
 export declare const chatConfigSchemaWithLegacyThemeName: z.ZodIntersection<z.ZodObject<{
 	showPredefinedQuestions: z.ZodOptional<z.ZodBoolean>;
@@ -17202,6 +17218,11 @@ export declare const chatConfigSchemaWithLegacyThemeName: z.ZodIntersection<z.Zo
 	addQueryToUrlParams: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
 	renderKatex: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
 	reflectLanguageInPath: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+	sendReferrer: z.ZodOptional<z.ZodOptional<z.ZodEnum<[
+		"all",
+		"own",
+		"none"
+	]>>>;
 }, "strip", z.ZodTypeAny, {
 	menu?: Partial<Record<"en" | "de" | "fr" | "it", {
 		url: string;
@@ -17653,6 +17674,7 @@ export declare const chatConfigSchemaWithLegacyThemeName: z.ZodIntersection<z.Zo
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }, {
 	menu?: Partial<Record<"en" | "de" | "fr" | "it", {
 		url: string;
@@ -18104,6 +18126,7 @@ export declare const chatConfigSchemaWithLegacyThemeName: z.ZodIntersection<z.Zo
 	addQueryToUrlParams?: boolean | undefined;
 	renderKatex?: boolean | undefined;
 	reflectLanguageInPath?: boolean | undefined;
+	sendReferrer?: "all" | "own" | "none" | undefined;
 }>, z.ZodObject<{
 	theme: z.ZodOptional<z.ZodObject<{
 		name: z.ZodOptional<z.ZodString>;
@@ -18140,13 +18163,15 @@ export type SseSubscriptionOptions = {
 	onMessage: (data: unknown) => void;
 	onError: (event: Event) => void;
 	onClose: () => void;
-	EventSource?: Constructor<EventSource>;
+	EventSource?: Constructor<SSE>;
+	apiKey?: string;
 };
 declare class SseSubscription {
 	private options;
+	private payload?;
 	private readonly eventSource;
 	private triggeredOnClose;
-	constructor(url: string, options: SseSubscriptionOptions);
+	constructor(url: string, options: SseSubscriptionOptions, payload?: Record<string, string> | undefined);
 	isClosed(): boolean;
 	close(): void;
 }
@@ -18210,6 +18235,7 @@ export type ChatOptions = {
 	lang?: string;
 	features?: string[];
 	version?: string;
+	referrer?: string;
 	onError?: OnError;
 	onMessage?: (message: SseMessageV2) => void;
 };

package/index.js

@@ -10644,7 +10644,8 @@ var completeChatConfigSchema = exports_external.object({
   buttonHref: exports_external.string().optional(),
   addQueryToUrlParams: exports_external.boolean().optional(),
   renderKatex: exports_external.boolean().optional(),
-  reflectLanguageInPath: exports_external.boolean().optional()
+  reflectLanguageInPath: exports_external.boolean().optional(),
+  sendReferrer: exports_external.enum(["all", "own", "none"]).optional()
 });
 var chatConfigSchema = completeChatConfigSchema.partial();
 var chatConfigSchemaWithLegacyThemeName = chatConfigSchema.and(exports_external.object({
@@ -10712,14 +10713,277 @@ var getUserData = async (restClient) => {
   }
 };
 
+// node_modules/.pnpm/sse.js@2.7.2/node_modules/sse.js/lib/sse.js
+var exports_sse = {};
+__export(exports_sse, {
+  SSE: () => SSE
+});
+var SSE = function(url, options2) {
+  if (!(this instanceof SSE)) {
+    return new SSE(url, options2);
+  }
+  this.url = url;
+  options2 = options2 || {};
+  this.headers = options2.headers || {};
+  this.payload = options2.payload !== undefined ? options2.payload : "";
+  this.method = options2.method || this.payload && "POST" || "GET";
+  this.withCredentials = !!options2.withCredentials;
+  this.debug = !!options2.debug;
+  this.autoReconnect = options2.autoReconnect !== undefined ? options2.autoReconnect : false;
+  this.reconnectDelay = options2.reconnectDelay !== undefined ? options2.reconnectDelay : 3000;
+  this.maxRetries = options2.maxRetries !== undefined ? options2.maxRetries : null;
+  this.retryCount = 0;
+  this.reconnectTimer = null;
+  this.useLastEventId = options2.useLastEventId !== undefined ? options2.useLastEventId : true;
+  this.FIELD_SEPARATOR = ":";
+  this.listeners = {};
+  this.xhr = null;
+  this.readyState = SSE.INITIALIZING;
+  this.progress = 0;
+  this.chunk = "";
+  this.lastEventId = "";
+  this.addEventListener = function(type, listener) {
+    if (this.listeners[type] === undefined) {
+      this.listeners[type] = [];
+    }
+    if (this.listeners[type].indexOf(listener) === -1) {
+      this.listeners[type].push(listener);
+    }
+  };
+  this.removeEventListener = function(type, listener) {
+    if (this.listeners[type] === undefined) {
+      return;
+    }
+    const filtered = [];
+    this.listeners[type].forEach(function(element2) {
+      if (element2 !== listener) {
+        filtered.push(element2);
+      }
+    });
+    if (filtered.length === 0) {
+      delete this.listeners[type];
+    } else {
+      this.listeners[type] = filtered;
+    }
+  };
+  this.dispatchEvent = function(e) {
+    if (!e) {
+      return true;
+    }
+    if (this.debug) {
+      console.debug(e);
+    }
+    e.source = this;
+    const onHandler = "on" + e.type;
+    if (this.hasOwnProperty(onHandler)) {
+      this[onHandler].call(this, e);
+      if (e.defaultPrevented) {
+        return false;
+      }
+    }
+    if (this.listeners[e.type]) {
+      return this.listeners[e.type].every(function(callback) {
+        callback(e);
+        return !e.defaultPrevented;
+      });
+    }
+    return true;
+  };
+  this._markClosed = function() {
+    this.xhr = null;
+    this.progress = 0;
+    this.chunk = "";
+    this._setReadyState(SSE.CLOSED);
+    if (this.autoReconnect) {
+      if (this.maxRetries !== null && this.retryCount >= this.maxRetries) {
+        if (this.debug) {
+          console.debug(`SSE max retries (${this.maxRetries}) reached, stopping reconnection attempts`);
+        }
+        this.autoReconnect = false;
+        this.close();
+        return;
+      }
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+      }
+      if (this.debug) {
+        console.debug(`SSE will attempt to reconnect in ${this.reconnectDelay}ms (attempt ${this.retryCount + 1}${this.maxRetries ? "/" + this.maxRetries : ""})`);
+      }
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        this.retryCount++;
+        this.stream();
+      }, this.reconnectDelay);
+    }
+  };
+  this._setReadyState = function(state2) {
+    const event2 = new CustomEvent("readystatechange");
+    event2.readyState = state2;
+    this.readyState = state2;
+    this.dispatchEvent(event2);
+  };
+  this._onStreamFailure = function(e) {
+    const event2 = new CustomEvent("error");
+    event2.responseCode = e.currentTarget.status;
+    event2.data = e.currentTarget.response;
+    this.dispatchEvent(event2);
+    this._markClosed();
+  };
+  this._onStreamAbort = function() {
+    this.dispatchEvent(new CustomEvent("abort"));
+    this._markClosed();
+  };
+  this._onStreamProgress = function(e) {
+    if (!this.xhr) {
+      return;
+    }
+    if (this.xhr.status < 200 || this.xhr.status >= 300) {
+      this._onStreamFailure(e);
+      return;
+    }
+    this.retryCount = 0;
+    const data = this.xhr.responseText.substring(this.progress);
+    this.progress += data.length;
+    const parts = (this.chunk + data).split(/(\r\n\r\n|\r\r|\n\n)/g);
+    const lastPart = parts.pop();
+    parts.forEach(function(part) {
+      if (part.trim().length > 0) {
+        this.dispatchEvent(this._parseEventChunk(part));
+      }
+    }.bind(this));
+    this.chunk = lastPart;
+  };
+  this._onStreamLoaded = function(e) {
+    this._onStreamProgress(e);
+    this.dispatchEvent(this._parseEventChunk(this.chunk));
+    this.chunk = "";
+    this._markClosed();
+  };
+  this._parseEventChunk = function(chunk) {
+    if (!chunk || chunk.length === 0) {
+      return null;
+    }
+    if (this.debug) {
+      console.debug(chunk);
+    }
+    const e = { id: null, retry: null, data: null, event: null };
+    chunk.split(/\n|\r\n|\r/).forEach(function(line) {
+      const index2 = line.indexOf(this.FIELD_SEPARATOR);
+      let field, value;
+      if (index2 > 0) {
+        const skip = line[index2 + 1] === " " ? 2 : 1;
+        field = line.substring(0, index2);
+        value = line.substring(index2 + skip);
+      } else if (index2 < 0) {
+        field = line;
+        value = "";
+      } else {
+        return;
+      }
+      if (!(field in e)) {
+        return;
+      }
+      if (field === "data" && e[field] !== null) {
+        e["data"] += `
+` + value;
+      } else {
+        e[field] = value;
+      }
+    }.bind(this));
+    if (e.data === null) {
+      return null;
+    }
+    if (e.id !== null) {
+      this.lastEventId = e.id;
+    }
+    const event2 = new CustomEvent(e.event || "message");
+    event2.id = e.id;
+    event2.data = e.data || "";
+    event2.lastEventId = this.lastEventId;
+    return event2;
+  };
+  this._onReadyStateChange = function() {
+    if (!this.xhr) {
+      return;
+    }
+    if (this.xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
+      const headers = {};
+      const headerPairs = this.xhr.getAllResponseHeaders().trim().split(`\r
+`);
+      for (const headerPair of headerPairs) {
+        const [key2, ...valueParts] = headerPair.split(":");
+        const value = valueParts.join(":").trim();
+        headers[key2.trim().toLowerCase()] = headers[key2.trim().toLowerCase()] || [];
+        headers[key2.trim().toLowerCase()].push(value);
+      }
+      const event2 = new CustomEvent("open");
+      event2.responseCode = this.xhr.status;
+      event2.headers = headers;
+      this.dispatchEvent(event2);
+      this._setReadyState(SSE.OPEN);
+    }
+  };
+  this.stream = function() {
+    if (this.xhr) {
+      return;
+    }
+    this._setReadyState(SSE.CONNECTING);
+    this.xhr = new XMLHttpRequest;
+    this.xhr.addEventListener("progress", this._onStreamProgress.bind(this));
+    this.xhr.addEventListener("load", this._onStreamLoaded.bind(this));
+    this.xhr.addEventListener("readystatechange", this._onReadyStateChange.bind(this));
+    this.xhr.addEventListener("error", this._onStreamFailure.bind(this));
+    this.xhr.addEventListener("abort", this._onStreamAbort.bind(this));
+    this.xhr.open(this.method, this.url);
+    for (let header in this.headers) {
+      this.xhr.setRequestHeader(header, this.headers[header]);
+    }
+    if (this.useLastEventId && this.lastEventId.length > 0) {
+      this.xhr.setRequestHeader("Last-Event-ID", this.lastEventId);
+    }
+    this.xhr.withCredentials = this.withCredentials;
+    this.xhr.send(this.payload);
+  };
+  this.close = function() {
+    if (this.readyState === SSE.CLOSED) {
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.autoReconnect = false;
+    this.xhr.abort();
+  };
+  if (options2.start === undefined || options2.start) {
+    this.stream();
+  }
+};
+SSE.INITIALIZING = -1;
+SSE.CONNECTING = 0;
+SSE.OPEN = 1;
+SSE.CLOSED = 2;
+if (typeof exports_sse !== "undefined") {
+  exports_sse.SSE = SSE;
+}
+
 // src/lib/client/api/sse-subscription.ts
 class SseSubscription {
   options;
+  payload;
   eventSource;
   triggeredOnClose = false;
-  constructor(url, options2) {
+  constructor(url, options2, payload) {
     this.options = options2;
-    this.eventSource = new (options2.EventSource ?? EventSource)(url);
+    this.payload = payload;
+    const sseoptions = { headers: { "content-type": "application/json" } };
+    if (payload) {
+      sseoptions.payload = JSON.stringify(payload);
+    }
+    if (options2.apiKey) {
+      sseoptions.headers["api-key"] = options2.apiKey;
+    }
+    this.eventSource = new (options2.EventSource ?? SSE)(url, sseoptions);
     this.eventSource.onmessage = (event2) => {
       try {
         const data = JSON.parse(event2.data);
@@ -10770,10 +11034,10 @@ class RestClient {
     return this.options.speechRecognitionApiKey;
   }
   async subscribeSse(path, params = {}, options2) {
-    const queryParams = removeUndefinedValues(params);
+    const payload = removeUndefinedValues(params);
     if (this.options.apiKey)
-      queryParams.key = this.options.apiKey;
-    return new SseSubscription(`${this.options.apiUrl}${path}?${new URLSearchParams(queryParams).toString()}`, options2);
+      options2.apiKey = this.options.apiKey;
+    return new SseSubscription(`${this.options.apiUrl}${path}`, options2, payload);
   }
   async fetchData(path, validator, params = {}, options2 = {}) {
     const url = `${this.options.apiUrl}${path}?${new URLSearchParams(removeUndefinedValues(params)).toString()}`;
@@ -11003,6 +11267,7 @@ class LiipGPTClientPrimitive {
         lang: options2.lang,
         model: options2.model,
         feature: options2.features?.join(","),
+        referrer: options2.referrer,
         chat: "true",
         version: "2"
       }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liip/liipgpt",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "description": "LiipGPT Chat and Library",
   "type": "module",
   "exports": {