@layla-network/sdk 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/index.ts
+// src/errors.ts
 var LaylaError = class extends Error {
   constructor(message) {
     super(message);
@@ -19,14 +19,8 @@ var LaylaBridgeUnavailableError = class extends LaylaError {
     this.name = "LaylaBridgeUnavailableError";
   }
 };
-var Deferred = class {
-  constructor() {
-    this.promise = new Promise((res, rej) => {
-      this.resolve = res;
-      this.reject = rej;
-    });
-  }
-};
+
+// src/internal/bridge.ts
 var _LaylaBridge = class _LaylaBridge {
   constructor() {
     this.queue = [];
@@ -44,27 +38,13 @@ var _LaylaBridge = class _LaylaBridge {
       if (!parsed || typeof parsed.event !== "string") return;
       const job = this.active;
       if (!job) return;
-      const sink = job.sink;
-      switch (parsed.event) {
-        case "on_message": {
-          const data = parsed.data ?? { msg: "", delta: "" };
-          sink.handleDelta(data.delta ?? "", data.msg ?? "");
-          break;
-        }
-        case "on_message_end": {
-          sink.handleEnd();
-          this.finishActive();
-          break;
-        }
-        case "on_error": {
-          const data = parsed.data;
-          sink.handleError(new LaylaError(data?.message || "Layla model error"));
-          this.finishActive();
-          break;
-        }
-        default:
-          break;
+      if (parsed.event === "on_error") {
+        const data = parsed.data;
+        job.sink.fail(new LaylaError(data?.message || "Layla model error"));
+        this.finishActive();
+        return;
       }
+      if (job.sink.accept(parsed)) this.finishActive();
     };
   }
   static shared() {
@@ -76,14 +56,33 @@ var _LaylaBridge = class _LaylaBridge {
     window.addEventListener("message", this.onWindowMessage);
     this.listening = true;
   }
-  enqueue(message, sink) {
+  enqueue(job) {
     this.ensureListening();
-    this.queue.push({ message, sink });
+    this.queue.push(job);
     this.pump();
   }
-  /** Remove a not-yet-started job (used when a queued request is aborted). */
-  cancelQueued(sink) {
-    this.queue = this.queue.filter((job) => job.sink !== sink);
+  /**
+   * Cancel a request.
+   *
+   * - If still queued (not yet sent), drop it; the host never sees it.
+   * - If it is the active (in-flight) request, ask the sink for a stop message
+   *   and post it (streaming generation -> `{ cmd: 'cancel' }`; one-shot -> none).
+   *   We deliberately do NOT free the active slot here: it frees when the host
+   *   sends the request's terminating event (`on_message_end` /
+   *   `on_get_characters_response` / `on_error`). Holding the slot until then
+   *   keeps any trailing event attributed to the (already-closed) sink — which
+   *   swallows it — instead of leaking into the next request.
+   */
+  cancel(sink) {
+    const remaining = this.queue.filter((job) => job.sink !== sink);
+    if (remaining.length !== this.queue.length) {
+      this.queue = remaining;
+      return;
+    }
+    if (this.active && this.active.sink === sink) {
+      const stop = sink.cancelMessage?.();
+      if (stop) this.post(stop);
+    }
   }
   finishActive() {
     this.active = null;
@@ -101,17 +100,33 @@ var _LaylaBridge = class _LaylaBridge {
     this.send(next);
   }
   send(job) {
-    if (typeof window === "undefined" || !window.ReactNativeWebView) {
+    if (!this.post(job.message)) {
       this.active = null;
-      job.sink.handleError(new LaylaBridgeUnavailableError());
+      job.sink.fail(new LaylaBridgeUnavailableError());
       this.pump();
-      return;
     }
-    window.ReactNativeWebView.postMessage(JSON.stringify(job.message));
+  }
+  /** Post a message to the host. Returns false if the bridge isn't present. */
+  post(message) {
+    if (typeof window === "undefined" || !window.ReactNativeWebView) return false;
+    window.ReactNativeWebView.postMessage(JSON.stringify(message));
+    return true;
   }
 };
 _LaylaBridge.instance = null;
 var LaylaBridge = _LaylaBridge;
+
+// src/internal/deferred.ts
+var Deferred = class {
+  constructor() {
+    this.promise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+};
+
+// src/resources/chat/stream.ts
 var ChatCompletionStream = class {
   constructor(model) {
     this.id = `chatcmpl-layla-${Date.now()}-${Math.floor(
@@ -150,7 +165,43 @@ var ChatCompletionStream = class {
       }
     }
   }
-  /* ---- StreamSink: driven by the bridge --------------------------------- */
+  /* ---- BridgeSink: driven by the bridge --------------------------------- */
+  accept(event) {
+    switch (event.event) {
+      case "on_message": {
+        const data = event.data ?? { msg: "", delta: "" };
+        this.handleDelta(data.delta ?? "", data.msg ?? "");
+        return false;
+      }
+      case "on_message_end":
+        this.handleEnd();
+        return true;
+      // terminal
+      default:
+        return false;
+    }
+  }
+  fail(err) {
+    if (this.closed) return;
+    this.failure = err;
+    this.closed = true;
+    this.drainError(err);
+    this.emit("error", err);
+    this.finalDeferred.reject(err);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  cancelMessage() {
+    return { cmd: "cancel" };
+  }
+  /** Abort from the consumer side. */
+  abort(reason) {
+    if (this.closed) return;
+    const err = reason instanceof Error ? reason : new LaylaAbortError();
+    this.fail(err);
+    LaylaBridge.shared().cancel(this);
+  }
   handleDelta(delta, snapshot) {
     if (this.closed) return;
     this.snapshot = snapshot || this.snapshot + delta;
@@ -171,24 +222,6 @@ var ChatCompletionStream = class {
     this.emit("end");
     this.finalDeferred.resolve(completion);
   }
-  handleError(err) {
-    if (this.closed) return;
-    this.failure = err;
-    this.closed = true;
-    this.drainError(err);
-    this.emit("error", err);
-    this.finalDeferred.reject(err);
-  }
-  isClosed() {
-    return this.closed;
-  }
-  /** Abort from the consumer side. */
-  abort(reason) {
-    if (this.closed) return;
-    const err = reason instanceof Error ? reason : new LaylaAbortError();
-    LaylaBridge.shared().cancelQueued(this);
-    this.handleError(err);
-  }
   /* ---- async iteration -------------------------------------------------- */
   next() {
     if (this.buffer.length) {
@@ -265,6 +298,8 @@ var ChatCompletionStream = class {
     };
   }
 };
+
+// src/resources/chat/index.ts
 var Completions = class {
   create(body) {
     const stream = this.startStream(
@@ -295,7 +330,10 @@ var Completions = class {
         { once: true }
       );
     }
-    LaylaBridge.shared().enqueue({ cmd: "send_message", data: messages }, stream);
+    LaylaBridge.shared().enqueue({
+      message: { cmd: "send_message", data: messages },
+      sink: stream
+    });
     return stream;
   }
 };
@@ -304,19 +342,216 @@ var Chat = class {
     this.completions = new Completions();
   }
 };
+
+// src/resources/images.ts
+var ImagesBridgeSink = class {
+  constructor() {
+    this.listeners = {};
+    this.closed = false;
+  }
+  on(event, listener) {
+    var _a;
+    ((_a = this.listeners)[event] || (_a[event] = [])).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const ls = this.listeners[event];
+    if (ls) this.listeners[event] = ls.filter((l) => l !== listener);
+    return this;
+  }
+  accept(event) {
+    switch (event.event) {
+      case "on_generate_image_progress":
+        for (const l of this.listeners["on_generate_image_progress"] ?? []) {
+          try {
+            l(event.data.status, event.data.steps, event.data.total_steps);
+          } catch {
+          }
+        }
+        return false;
+      // not terminal
+      case "on_generate_image_response":
+        for (const l of this.listeners["on_generate_image_response"] ?? []) {
+          try {
+            l(event.data?.image_data_base64 || null);
+          } catch {
+          }
+        }
+        return true;
+      // terminal
+      default:
+        return false;
+    }
+  }
+  fail(_) {
+    if (this.closed) return;
+    this.closed = true;
+  }
+  isClosed() {
+    return this.closed;
+  }
+  cancelMessage() {
+    return null;
+  }
+  /** Abort from the consumer side. */
+  abort(reason) {
+    const err = reason instanceof Error ? reason : new LaylaAbortError();
+    this.fail(err);
+    LaylaBridge.shared().cancel(this);
+  }
+};
+var Images = class {
+  /**
+   * Ask the native host to generate an image. Resolves to a ready-to-use base64 image src string, or null if the character has no image
+   */
+  generateImage(prompt, onProgress, options = {}) {
+    const setupSince = () => {
+      const sink = new ImagesBridgeSink();
+      if (options.signal?.aborted) {
+        queueMicrotask(() => sink.abort(new LaylaAbortError()));
+        return sink;
+      }
+      if (options.signal) {
+        options.signal.addEventListener(
+          "abort",
+          () => sink.abort(new LaylaAbortError()),
+          { once: true }
+        );
+      }
+      LaylaBridge.shared().enqueue({
+        message: { cmd: "generate_image", data: { prompt } },
+        sink
+      });
+      return sink;
+    };
+    return new Promise((resolve, reject) => {
+      const sink = setupSince();
+      sink.on("on_generate_image_response", (image_data_base64) => {
+        resolve(image_data_base64);
+      });
+      sink.on("on_generate_image_progress", (status, step, total_step) => {
+        onProgress(status, step, total_step);
+      });
+      const onFailure = (err) => {
+        reject(err);
+      };
+      options.signal?.addEventListener("abort", () => {
+        onFailure(new LaylaAbortError());
+      });
+    });
+  }
+};
+
+// src/internal/one-shot.ts
+var OneShotRequest = class {
+  constructor(command, responseEvent, extract) {
+    this.responseEvent = responseEvent;
+    this.extract = extract;
+    this.closed = false;
+    this.deferred = new Deferred();
+    this.deferred.promise.catch(() => void 0);
+    this.job = { message: command, sink: this };
+  }
+  get promise() {
+    return this.deferred.promise;
+  }
+  accept(event) {
+    if (event.event !== this.responseEvent) return false;
+    if (!this.closed) {
+      this.closed = true;
+      try {
+        this.deferred.resolve(this.extract(event));
+      } catch (err) {
+        this.deferred.reject(
+          err instanceof Error ? err : new LaylaError(String(err))
+        );
+      }
+    }
+    return true;
+  }
+  fail(err) {
+    if (this.closed) return;
+    this.closed = true;
+    this.deferred.reject(err);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  // No cancelMessage(): a one-shot has no generation to stop on the host side.
+  /** Abort from the consumer side. */
+  abort(reason) {
+    if (this.closed) return;
+    const err = reason instanceof Error ? reason : new LaylaAbortError();
+    this.fail(err);
+    LaylaBridge.shared().cancel(this);
+  }
+};
+function oneShot(command, responseEvent, extract, signal) {
+  const req = new OneShotRequest(command, responseEvent, extract);
+  if (signal?.aborted) {
+    queueMicrotask(() => req.abort(new LaylaAbortError()));
+    return req.promise;
+  }
+  if (signal) {
+    signal.addEventListener("abort", () => req.abort(new LaylaAbortError()), {
+      once: true
+    });
+  }
+  LaylaBridge.shared().enqueue(req.job);
+  return req.promise;
+}
+
+// src/resources/characters.ts
+var Characters = class {
+  /**
+   * Ask the native host for the available character cards. Resolves once with
+   * the host's `on_get_characters_response` payload, or rejects on error/abort.
+   */
+  list(options = {}) {
+    return oneShot(
+      { cmd: "get_characters" },
+      "on_get_characters_response",
+      (event) => {
+        const data = event.data;
+        return Array.isArray(data) ? data : [];
+      },
+      options.signal
+    );
+  }
+  /**
+   * Ask the native host for a character portrait. Resolves to a ready-to-use
+   * image src string, or null when the character has no image.
+   */
+  getImage(characterId, options = {}) {
+    return oneShot(
+      { cmd: "get_character_image", data: { character_id: characterId } },
+      "on_get_character_image_response",
+      (event) => {
+        const data = event.data;
+        return data?.image_data_base64 ?? null;
+      },
+      options.signal
+    );
+  }
+};
+
+// src/client.ts
 var LaylaSDK = class {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   constructor(_options = {}) {
     this.chat = new Chat();
+    this.characters = new Characters();
+    this.images = new Images();
   }
 };
-var index_default = LaylaSDK;
+var client_default = LaylaSDK;
 export {
   ChatCompletionStream,
+  Images,
   LaylaSDK as Layla,
   LaylaAbortError,
   LaylaBridgeUnavailableError,
   LaylaError,
   LaylaSDK,
-  index_default as default
+  client_default as default
 };

package/package.json

@@ -1,32 +1,43 @@
-{
-  "name": "@layla-network/sdk",
-  "version": "0.1.0",
-  "description": "Layla custom mini-apps SDK",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
-    "prepublishOnly": "npm run build"
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "tsup": "^8.0.0",
-    "typescript": "^5.4.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@layla-network/sdk",
+  "version": "0.1.1",
+  "description": "Layla custom mini-apps SDK",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "vite-plugin-singlefile": "^2.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/l3utterfly/layla-sdk.git"
+  },
+  "homepage": "https://github.com/l3utterfly/layla-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/l3utterfly/layla-sdk/issues"
+  }
+}