@rndev77/suzu-ai 0.1.0 → 0.1.2

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "SUZU production chat panel as a vanilla embed",
   "type": "module",
   "main": "./src/index.js",
@@ -22,9 +22,6 @@
   "sideEffects": [
     "./src/style.css"
   ],
-  "dependencies": {
-    "@rndev77/suzu-ai-core": "0.1.0"
-  },
   "license": "MIT",
   "keywords": [
     "suzu",

package/src/core.d.ts

@@ -0,0 +1,31 @@
+export interface SuzuChatHandlers {
+  [event: string]: (data?: any) => void;
+}
+
+export interface SuzuChatOptions {
+  apiBase: string;
+  apiKey: string;
+  on?: SuzuChatHandlers;
+}
+
+export interface SuzuChat {
+  ready(): boolean;
+  sessionId(): string | null;
+  busy(): boolean;
+  reset(): void;
+  setSession(id?: string | null): void;
+  welcome(): Promise<any>;
+  newChat(): Promise<any>;
+  messages(id: string): Promise<any[]>;
+  listing(pid: string): Promise<any>;
+  imageUrl(image: any): Promise<string>;
+  send(text: string, isMore?: boolean): Promise<void>;
+  sendLocation(location: any): void;
+}
+
+export interface SuzuChatConstructor {
+  new (options: SuzuChatOptions): SuzuChat;
+}
+
+export const SuzuChat: SuzuChatConstructor;
+export default SuzuChat;

package/src/core.js

@@ -0,0 +1,272 @@
+function trimSlash(url) {
+  return String(url || "").replace(/\/+$/, "");
+}
+
+function parseSseBlock(block) {
+  var eventName = "text";
+  var dataLines = [];
+  String(block).split(/\r?\n/).forEach(function (line) {
+    if (line.indexOf("event:") === 0) eventName = line.slice(6).trim();
+    else if (line.indexOf("data:") === 0) dataLines.push(line.slice(5).trim());
+  });
+  var payload = {};
+  if (dataLines.length) {
+    try { payload = JSON.parse(dataLines.join("\n")); } catch (err) {}
+  }
+  return { event: eventName, data: payload };
+}
+
+function storageKey(api, apiKey) {
+  return "suzu_partner_auth::" + api + "::" + apiKey;
+}
+
+function readStored(api, apiKey) {
+  try { return localStorage.getItem(storageKey(api, apiKey)) || ""; }
+  catch (err) { return ""; }
+}
+
+function writeStored(api, apiKey, token) {
+  try {
+    var key = storageKey(api, apiKey);
+    if (token) localStorage.setItem(key, token);
+    else localStorage.removeItem(key);
+  } catch (err) {}
+}
+
+export function SuzuChat(opts) {
+  opts = opts || {};
+  var api = trimSlash(opts.apiBase);
+  var apiKey = String(opts.apiKey || "");
+  var sessionId = null;
+  var sending = false;
+  var handlers = opts.on || {};
+  var credential = readStored(api, apiKey) || apiKey;
+  var imageCache = Object.create(null);
+  var imageWait = Object.create(null);
+  var imageQueue = [];
+  var imageInflight = 0;
+  var IMAGE_CONCURRENCY = 3;
+
+  function pumpImageQueue() {
+    while (imageInflight < IMAGE_CONCURRENCY && imageQueue.length) {
+      (function (job) {
+        imageInflight++;
+        Promise.resolve()
+          .then(job)
+          .then(function () {
+            imageInflight--;
+            pumpImageQueue();
+          }, function () {
+            imageInflight--;
+            pumpImageQueue();
+          });
+      })(imageQueue.shift());
+    }
+  }
+
+  function enqueueImage(run) {
+    return new Promise(function (resolve) {
+      imageQueue.push(function () {
+        return Promise.resolve()
+          .then(run)
+          .then(function (url) {
+            resolve(url || "");
+            return url;
+          }, function () {
+            resolve("");
+            return "";
+          });
+      });
+      pumpImageQueue();
+    });
+  }
+
+  function emit(name, arg) {
+    if (typeof handlers[name] === "function") handlers[name](arg);
+  }
+
+  function consumeAuth(data) {
+    var token = data && data.access_token ? String(data.access_token) : "";
+    if (!token) return;
+    credential = token;
+    writeStored(api, apiKey, token);
+  }
+
+  function authHeaders(json, sse) {
+    var h = { "Accept-Language": "ru-RU,ru;q=0.9" };
+    if (credential) h.Authorization = "Bearer " + credential;
+    if (json) h["Content-Type"] = "application/json";
+    if (sse) h.Accept = "text/event-stream";
+    return h;
+  }
+
+  function clearVisitor() {
+    credential = apiKey;
+    writeStored(api, apiKey, "");
+  }
+
+  async function authedFetch(path, init, allowRetry) {
+    var resp = await fetch(api + path, Object.assign({}, init || {}, {
+      headers: Object.assign({}, authHeaders(false, false), (init && init.headers) || {})
+    }));
+    if (resp.status !== 401 || !allowRetry) return resp;
+    if (credential && credential !== apiKey) {
+      clearVisitor();
+      await welcome();
+      return fetch(api + path, Object.assign({}, init || {}, {
+        headers: Object.assign({}, authHeaders(false, false), (init && init.headers) || {})
+      }));
+    }
+    return resp;
+  }
+
+  async function welcome() {
+    if (!api || !apiKey) return { suggestions: [] };
+    var resp = await fetch(api + "/api/chat/welcome", { headers: authHeaders(false, false) });
+    if (!resp.ok) throw new Error("welcome " + resp.status);
+    var data = await resp.json();
+    if (data && data.auth) consumeAuth(data.auth);
+    return data || { suggestions: [] };
+  }
+
+  async function readSse(stream) {
+    var reader = stream.getReader();
+    var decoder = new TextDecoder();
+    var buffer = "";
+    var done = false;
+    while (!done) {
+      var chunk = await reader.read();
+      done = chunk.done;
+      buffer += decoder.decode(chunk.value || new Uint8Array(), { stream: !done });
+      var blocks = buffer.split(/\r?\n\r?\n/);
+      buffer = blocks.pop() || "";
+      blocks.forEach(function (block) {
+        if (!block.trim()) return;
+        var parsed = parseSseBlock(block);
+        if (parsed.event === "auth") consumeAuth(parsed.data);
+        if (parsed.event === "session" && parsed.data.session_id) {
+          sessionId = String(parsed.data.session_id);
+        }
+        emit(parsed.event, parsed.data);
+      });
+    }
+  }
+
+  async function postChat(payload) {
+    if (!credential) await welcome();
+    var resp = await fetch(api + "/api/chat", {
+      method: "POST",
+      headers: authHeaders(true, true),
+      body: JSON.stringify(payload)
+    });
+    if (!resp.ok) throw new Error("chat " + resp.status);
+    if (resp.body) await readSse(resp.body);
+  }
+
+  this.ready = function () { return !!api && !!apiKey; };
+  this.sessionId = function () { return sessionId; };
+  this.busy = function () { return sending; };
+  this.reset = function () {
+    sessionId = null;
+    sending = false;
+  };
+  this.setSession = function (id) { sessionId = id || null; };
+  this.welcome = function () {
+    return welcome().catch(function () { return { suggestions: [] }; });
+  };
+  this.newChat = function () {
+    if (!api || !apiKey) return Promise.resolve(null);
+    return authedFetch("/api/chats/new", { method: "POST" }, true)
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (data) {
+        if (data && data.auth) consumeAuth(data.auth);
+        sessionId = data && data.session_id ? String(data.session_id) : null;
+        return data;
+      })
+      .catch(function () { return null; });
+  };
+  this.messages = function (id) {
+    if (!api || !apiKey || !id) return Promise.resolve([]);
+    return authedFetch("/api/chats/" + encodeURIComponent(id) + "/messages", {}, true)
+      .then(function (r) { return r.ok ? r.json() : { messages: [] }; })
+      .then(function (data) {
+        if (data && data.auth) consumeAuth(data.auth);
+        return data.messages || [];
+      })
+      .catch(function () { return []; });
+  };
+  this.listing = function (pid) {
+    if (!api || !apiKey || !pid) return Promise.resolve(null);
+    return authedFetch("/api/listings/" + encodeURIComponent(pid) + "?lang=ru", {}, true)
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (data) {
+        if (data && data.auth) consumeAuth(data.auth);
+        return data && data.listing ? data.listing : data;
+      })
+      .catch(function () { return null; });
+  };
+  this.imageUrl = function (image) {
+    if (!image || !api || !apiKey) return Promise.resolve("");
+    var path = typeof image.delivery_url === "string" && image.delivery_url
+      ? image.delivery_url
+      : (image.id ? "/api/listings/images/" + image.id + "/file" : "");
+    if (!path) return Promise.resolve("");
+    var key = /^https?:\/\//i.test(path) ? path : (api + path);
+    if (imageCache[key]) return Promise.resolve(imageCache[key]);
+    if (imageWait[key]) return imageWait[key];
+    imageWait[key] = enqueueImage(function () {
+      if (imageCache[key]) return imageCache[key];
+      return authedFetch(key.indexOf(api) === 0 ? key.slice(api.length) : path, {}, true)
+        .then(function (r) { return r.ok ? r.blob() : null; })
+        .then(function (blob) {
+          if (!blob) return "";
+          var url = URL.createObjectURL(blob);
+          imageCache[key] = url;
+          return url;
+        })
+        .catch(function () { return ""; });
+    }).then(function (url) {
+      delete imageWait[key];
+      return url;
+    }, function () {
+      delete imageWait[key];
+      return "";
+    });
+    return imageWait[key];
+  };
+  this.send = async function (text, isMore) {
+    if (!api || !apiKey || sending) return;
+    var content = String(text || "").trim();
+    if (!isMore && !content) return;
+    if (isMore && !sessionId) {
+      emit("error", { detail: "Нет активной сессии для подгрузки." });
+      return;
+    }
+    sending = true;
+    emit("start", { text: content, more: !!isMore });
+    try {
+      var payload = {
+        content: isMore ? "" : content,
+        is_more: !!isMore
+      };
+      if (sessionId) payload.session_id = sessionId;
+      await postChat(payload);
+      emit("done", {});
+    } catch (err) {
+      emit("error", { detail: "Не удалось связаться с ассистентом. Попробуйте ещё раз." });
+    } finally {
+      sending = false;
+      emit("idle", {});
+    }
+  };
+  this.sendLocation = function (location) {
+    if (!api || !apiKey || !sessionId) return;
+    authedFetch("/api/chat", {
+      method: "POST",
+      headers: authHeaders(true, false),
+      body: JSON.stringify({ session_id: sessionId, location: location })
+    }, true).catch(function () {});
+  };
+}
+
+export default SuzuChat;

package/src/index.d.ts

@@ -1,4 +1,4 @@
-import { SuzuChat } from "@rndev77/suzu-ai-core";
+import { SuzuChat } from "./core.js";
 
 export interface SuzuWidgetOptions {
   apiBase: string;

package/src/index.js

@@ -1,4 +1,4 @@
-import { SuzuChat } from "@rndev77/suzu-ai-core";
+import { SuzuChat } from "./core.js";
 import { bindSuzuPanel } from "./bind-panel.js";
 import { launcherMarkup, panelMarkup } from "./markup.js";