@liip/liipgpt 2.3.5 → 2.5.0

package/index.cjs

@@ -10425,7 +10425,8 @@ var svgsSchema = exports_external.record(exports_external.enum([
   "speechInput",
   "listUnordered",
   "lightMode",
-  "darkMode"
+  "darkMode",
+  "avatarLarge"
 ]), exports_external.string());
 var tokensSchema = exports_external.object({
   font: fontSchema.optional(),
@@ -10680,7 +10681,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({
@@ -10748,14 +10750,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);
@@ -10806,10 +11071,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()}`;
@@ -11039,6 +11304,7 @@ class LiipGPTClientPrimitive {
         lang: options2.lang,
         model: options2.model,
         feature: options2.features?.join(","),
+        referrer: options2.referrer,
         chat: "true",
         version: "2"
       }, {