@layla-network/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,352 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatCompletionStream: () => ChatCompletionStream,
+  Layla: () => LaylaSDK,
+  LaylaAbortError: () => LaylaAbortError,
+  LaylaBridgeUnavailableError: () => LaylaBridgeUnavailableError,
+  LaylaError: () => LaylaError,
+  LaylaSDK: () => LaylaSDK,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var LaylaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LaylaError";
+  }
+};
+var LaylaAbortError = class extends LaylaError {
+  constructor(message = "Request was aborted") {
+    super(message);
+    this.name = "LaylaAbortError";
+  }
+};
+var LaylaBridgeUnavailableError = class extends LaylaError {
+  constructor() {
+    super(
+      "Layla bridge unavailable: window.ReactNativeWebView is not present. Make sure this code runs inside the Layla WebView and that the <WebView> has its `onMessage` prop set (that is what injects the bridge)."
+    );
+    this.name = "LaylaBridgeUnavailableError";
+  }
+};
+var Deferred = class {
+  constructor() {
+    this.promise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+};
+var _LaylaBridge = class _LaylaBridge {
+  constructor() {
+    this.queue = [];
+    this.active = null;
+    this.listening = false;
+    this.onWindowMessage = (event) => {
+      const raw = event.data;
+      if (typeof raw !== "string") return;
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      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;
+      }
+    };
+  }
+  static shared() {
+    if (!_LaylaBridge.instance) _LaylaBridge.instance = new _LaylaBridge();
+    return _LaylaBridge.instance;
+  }
+  ensureListening() {
+    if (this.listening || typeof window === "undefined") return;
+    window.addEventListener("message", this.onWindowMessage);
+    this.listening = true;
+  }
+  enqueue(message, sink) {
+    this.ensureListening();
+    this.queue.push({ message, sink });
+    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);
+  }
+  finishActive() {
+    this.active = null;
+    this.pump();
+  }
+  pump() {
+    if (this.active) return;
+    const next = this.queue.shift();
+    if (!next) return;
+    if (next.sink.isClosed()) {
+      this.pump();
+      return;
+    }
+    this.active = next;
+    this.send(next);
+  }
+  send(job) {
+    if (typeof window === "undefined" || !window.ReactNativeWebView) {
+      this.active = null;
+      job.sink.handleError(new LaylaBridgeUnavailableError());
+      this.pump();
+      return;
+    }
+    window.ReactNativeWebView.postMessage(JSON.stringify(job.message));
+  }
+};
+_LaylaBridge.instance = null;
+var LaylaBridge = _LaylaBridge;
+var ChatCompletionStream = class {
+  constructor(model) {
+    this.id = `chatcmpl-layla-${Date.now()}-${Math.floor(
+      Math.random() * 1e6
+    )}`;
+    this.created = Math.floor(Date.now() / 1e3);
+    this.buffer = [];
+    this.resolvers = [];
+    this.rejectors = [];
+    this.snapshot = "";
+    this.ended = false;
+    this.closed = false;
+    this.failure = null;
+    this.listeners = {};
+    this.finalDeferred = new Deferred();
+    this.model = model;
+    this.finalDeferred.promise.catch(() => void 0);
+  }
+  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;
+  }
+  emit(event, ...args) {
+    const ls = this.listeners[event];
+    if (!ls) return;
+    for (const l of ls.slice()) {
+      try {
+        l(...args);
+      } catch {
+      }
+    }
+  }
+  /* ---- StreamSink: driven by the bridge --------------------------------- */
+  handleDelta(delta, snapshot) {
+    if (this.closed) return;
+    this.snapshot = snapshot || this.snapshot + delta;
+    const chunk = this.makeChunk({ content: delta }, null);
+    this.pushChunk(chunk);
+    this.emit("chunk", chunk);
+    if (delta) this.emit("content", delta, this.snapshot);
+  }
+  handleEnd() {
+    if (this.closed) return;
+    const finalChunk = this.makeChunk({}, "stop");
+    this.pushChunk(finalChunk);
+    this.emit("chunk", finalChunk);
+    this.ended = true;
+    this.closed = true;
+    this.drainDone();
+    const completion = this.buildCompletion();
+    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) {
+      return Promise.resolve({ value: this.buffer.shift(), done: false });
+    }
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.ended) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve, reject) => {
+      this.resolvers.push(resolve);
+      this.rejectors.push(reject);
+    });
+  }
+  /** Breaking out of `for await` aborts the request, like the OpenAI SDK. */
+  return() {
+    this.abort(new LaylaAbortError("Stream consumer stopped"));
+    return Promise.resolve({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  /* ---- convenience promises -------------------------------------------- */
+  finalChatCompletion() {
+    return this.finalDeferred.promise;
+  }
+  async finalContent() {
+    const completion = await this.finalDeferred.promise;
+    return completion.choices[0]?.message.content ?? "";
+  }
+  /* ---- internals -------------------------------------------------------- */
+  pushChunk(chunk) {
+    if (this.resolvers.length) {
+      this.resolvers.shift()({ value: chunk, done: false });
+      this.rejectors.shift();
+    } else {
+      this.buffer.push(chunk);
+    }
+  }
+  drainDone() {
+    while (this.resolvers.length) {
+      this.resolvers.shift()({ value: void 0, done: true });
+      this.rejectors.shift();
+    }
+  }
+  drainError(err) {
+    while (this.rejectors.length) {
+      this.rejectors.shift()(err);
+      this.resolvers.shift();
+    }
+  }
+  makeChunk(delta, finish) {
+    return {
+      id: this.id,
+      object: "chat.completion.chunk",
+      created: this.created,
+      model: this.model,
+      choices: [{ index: 0, delta, finish_reason: finish }]
+    };
+  }
+  buildCompletion() {
+    return {
+      id: this.id,
+      object: "chat.completion",
+      created: this.created,
+      model: this.model,
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: this.snapshot },
+          finish_reason: "stop"
+        }
+      ]
+    };
+  }
+};
+var Completions = class {
+  create(body) {
+    const stream = this.startStream(
+      body.messages,
+      body.model ?? "layla",
+      body.signal
+    );
+    if (body.stream) return Promise.resolve(stream);
+    return stream.finalChatCompletion();
+  }
+  /**
+   * OpenAI-style helper: returns the live stream object synchronously (not a
+   * promise), so you can attach `.on(...)` listeners before any token arrives.
+   */
+  stream(body) {
+    return this.startStream(body.messages, body.model ?? "layla", body.signal);
+  }
+  startStream(messages, model, signal) {
+    const stream = new ChatCompletionStream(model);
+    if (signal?.aborted) {
+      queueMicrotask(() => stream.abort(new LaylaAbortError()));
+      return stream;
+    }
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => stream.abort(new LaylaAbortError()),
+        { once: true }
+      );
+    }
+    LaylaBridge.shared().enqueue({ cmd: "send_message", data: messages }, stream);
+    return stream;
+  }
+};
+var Chat = class {
+  constructor() {
+    this.completions = new Completions();
+  }
+};
+var LaylaSDK = class {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(_options = {}) {
+    this.chat = new Chat();
+  }
+};
+var index_default = LaylaSDK;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatCompletionStream,
+  Layla,
+  LaylaAbortError,
+  LaylaBridgeUnavailableError,
+  LaylaError,
+  LaylaSDK
+});

package/dist/index.d.cts

@@ -0,0 +1,208 @@
+/**
+ * LaylaSDK
+ * --------
+ * A web-side client (runs INSIDE the Layla WebView) that talks to the native
+ * Layla app over the React Native WebView bridge, exposed through an API that
+ * mirrors the OpenAI JavaScript SDK so existing OpenAI code ports with minimal
+ * friction.
+ *
+ * The native host runs the model and streams tokens back; this SDK turns that
+ * event stream into the OpenAI shapes (`ChatCompletion`, `ChatCompletionChunk`)
+ * and an async-iterable stream.
+ *
+ * Wire protocol (must match the React Native host):
+ *   Web -> RN : { cmd: 'send_message', data: LaylaChatMessage[] }
+ *   RN -> Web : { event: 'on_message',     data: { msg, delta } }   (per token)
+ *               { event: 'on_message_end' }                          (end)
+ *               { event: 'on_error',       data: { message } }       (error)
+ *
+ * Quick start:
+ *
+ *   import { LaylaSDK } from './layla-sdk';
+ *   const layla = new LaylaSDK();
+ *
+ *   // Streaming (async iteration) -- the OpenAI way:
+ *   const stream = await layla.chat.completions.create({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *     stream: true,
+ *   });
+ *   for await (const chunk of stream) {
+ *     process_token(chunk.choices[0]?.delta?.content ?? '');
+ *   }
+ *
+ *   // Streaming (event helper) -- maps cleanly onto Layla's delta/snapshot:
+ *   const s = layla.chat.completions.stream({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ *   s.on('content', (delta, snapshot) => render(snapshot));
+ *   const final = await s.finalContent();
+ *
+ *   // Non-streaming -- resolves once when the model is done:
+ *   const completion = await layla.chat.completions.create({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ *   console.log(completion.choices[0].message.content);
+ */
+type LaylaChatRole = 'system' | 'user' | 'assistant' | 'tool' | 'function';
+/** An OpenAI-style chat message. */
+interface LaylaChatMessage {
+    role: LaylaChatRole;
+    content: string | null;
+    name?: string;
+}
+/** Web -> RN command. */
+interface LaylaApiMessage {
+    cmd: 'send_message';
+    data: LaylaChatMessage[];
+}
+/** RN -> Web: a streamed token. `msg` is the full snapshot, `delta` is new. */
+interface LaylaApiEvent_onMsg {
+    event: 'on_message';
+    data: {
+        msg: string;
+        delta: string;
+    };
+}
+/** RN -> Web: stream finished. */
+interface LaylaApiEvent_onMsgEnd {
+    event: 'on_message_end';
+}
+/** RN -> Web: error. */
+interface LaylaApiEvent_onError {
+    event: 'on_error';
+    data: {
+        message: string;
+    };
+}
+type LaylaApiEvent = LaylaApiEvent_onMsg | LaylaApiEvent_onMsgEnd | LaylaApiEvent_onError;
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: 'assistant';
+            content?: string;
+        };
+        finish_reason: 'stop' | null;
+    }>;
+}
+interface ChatCompletion {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: 'assistant';
+            content: string;
+        };
+        finish_reason: 'stop';
+    }>;
+}
+interface ChatCompletionCreateParamsBase {
+    messages: LaylaChatMessage[];
+    /**
+     * Accepted for OpenAI compatibility. The Layla host currently picks the
+     * model itself, so this is only used to populate the `model` field on the
+     * returned objects unless you extend the `send_message` protocol.
+     */
+    model?: string;
+    stream?: boolean;
+    /** Abort the request from the consumer side. */
+    signal?: AbortSignal;
+}
+interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+    stream?: false;
+}
+interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+    stream: true;
+}
+declare class LaylaError extends Error {
+    constructor(message: string);
+}
+declare class LaylaAbortError extends LaylaError {
+    constructor(message?: string);
+}
+declare class LaylaBridgeUnavailableError extends LaylaError {
+    constructor();
+}
+declare global {
+    interface Window {
+        ReactNativeWebView?: {
+            postMessage: (message: string) => void;
+        };
+    }
+}
+/** Implemented by ChatCompletionStream; the bridge drives it. */
+interface StreamSink {
+    handleDelta(delta: string, snapshot: string): void;
+    handleEnd(): void;
+    handleError(err: Error): void;
+    isClosed(): boolean;
+}
+type Listener = (...args: any[]) => void;
+declare class ChatCompletionStream implements StreamSink, AsyncIterable<ChatCompletionChunk> {
+    private readonly id;
+    private readonly created;
+    private readonly model;
+    private buffer;
+    private resolvers;
+    private rejectors;
+    private snapshot;
+    private ended;
+    private closed;
+    private failure;
+    private listeners;
+    private finalDeferred;
+    constructor(model: string);
+    on(event: 'content', listener: (delta: string, snapshot: string) => void): this;
+    on(event: 'chunk', listener: (chunk: ChatCompletionChunk) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    off(event: string, listener: Listener): this;
+    private emit;
+    handleDelta(delta: string, snapshot: string): void;
+    handleEnd(): void;
+    handleError(err: Error): void;
+    isClosed(): boolean;
+    /** Abort from the consumer side. */
+    abort(reason?: unknown): void;
+    next(): Promise<IteratorResult<ChatCompletionChunk>>;
+    /** Breaking out of `for await` aborts the request, like the OpenAI SDK. */
+    return(): Promise<IteratorResult<ChatCompletionChunk>>;
+    [Symbol.asyncIterator](): AsyncIterator<ChatCompletionChunk>;
+    finalChatCompletion(): Promise<ChatCompletion>;
+    finalContent(): Promise<string>;
+    private pushChunk;
+    private drainDone;
+    private drainError;
+    private makeChunk;
+    private buildCompletion;
+}
+declare class Completions {
+    create(body: ChatCompletionCreateParamsNonStreaming): Promise<ChatCompletion>;
+    create(body: ChatCompletionCreateParamsStreaming): Promise<ChatCompletionStream>;
+    /**
+     * OpenAI-style helper: returns the live stream object synchronously (not a
+     * promise), so you can attach `.on(...)` listeners before any token arrives.
+     */
+    stream(body: Omit<ChatCompletionCreateParamsBase, 'stream'>): ChatCompletionStream;
+    private startStream;
+}
+declare class Chat {
+    readonly completions: Completions;
+}
+interface LaylaSDKOptions {
+    /** Reserved for future use (e.g. default model). */
+    model?: string;
+}
+declare class LaylaSDK {
+    readonly chat: Chat;
+    constructor(_options?: LaylaSDKOptions);
+}
+
+export { type ChatCompletion, type ChatCompletionChunk, type ChatCompletionCreateParamsBase, type ChatCompletionCreateParamsNonStreaming, type ChatCompletionCreateParamsStreaming, ChatCompletionStream, LaylaSDK as Layla, LaylaAbortError, type LaylaApiEvent, type LaylaApiEvent_onError, type LaylaApiEvent_onMsg, type LaylaApiEvent_onMsgEnd, type LaylaApiMessage, LaylaBridgeUnavailableError, type LaylaChatMessage, type LaylaChatRole, LaylaError, LaylaSDK, type LaylaSDKOptions, LaylaSDK as default };

package/dist/index.d.ts

@@ -0,0 +1,208 @@
+/**
+ * LaylaSDK
+ * --------
+ * A web-side client (runs INSIDE the Layla WebView) that talks to the native
+ * Layla app over the React Native WebView bridge, exposed through an API that
+ * mirrors the OpenAI JavaScript SDK so existing OpenAI code ports with minimal
+ * friction.
+ *
+ * The native host runs the model and streams tokens back; this SDK turns that
+ * event stream into the OpenAI shapes (`ChatCompletion`, `ChatCompletionChunk`)
+ * and an async-iterable stream.
+ *
+ * Wire protocol (must match the React Native host):
+ *   Web -> RN : { cmd: 'send_message', data: LaylaChatMessage[] }
+ *   RN -> Web : { event: 'on_message',     data: { msg, delta } }   (per token)
+ *               { event: 'on_message_end' }                          (end)
+ *               { event: 'on_error',       data: { message } }       (error)
+ *
+ * Quick start:
+ *
+ *   import { LaylaSDK } from './layla-sdk';
+ *   const layla = new LaylaSDK();
+ *
+ *   // Streaming (async iteration) -- the OpenAI way:
+ *   const stream = await layla.chat.completions.create({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *     stream: true,
+ *   });
+ *   for await (const chunk of stream) {
+ *     process_token(chunk.choices[0]?.delta?.content ?? '');
+ *   }
+ *
+ *   // Streaming (event helper) -- maps cleanly onto Layla's delta/snapshot:
+ *   const s = layla.chat.completions.stream({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ *   s.on('content', (delta, snapshot) => render(snapshot));
+ *   const final = await s.finalContent();
+ *
+ *   // Non-streaming -- resolves once when the model is done:
+ *   const completion = await layla.chat.completions.create({
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ *   console.log(completion.choices[0].message.content);
+ */
+type LaylaChatRole = 'system' | 'user' | 'assistant' | 'tool' | 'function';
+/** An OpenAI-style chat message. */
+interface LaylaChatMessage {
+    role: LaylaChatRole;
+    content: string | null;
+    name?: string;
+}
+/** Web -> RN command. */
+interface LaylaApiMessage {
+    cmd: 'send_message';
+    data: LaylaChatMessage[];
+}
+/** RN -> Web: a streamed token. `msg` is the full snapshot, `delta` is new. */
+interface LaylaApiEvent_onMsg {
+    event: 'on_message';
+    data: {
+        msg: string;
+        delta: string;
+    };
+}
+/** RN -> Web: stream finished. */
+interface LaylaApiEvent_onMsgEnd {
+    event: 'on_message_end';
+}
+/** RN -> Web: error. */
+interface LaylaApiEvent_onError {
+    event: 'on_error';
+    data: {
+        message: string;
+    };
+}
+type LaylaApiEvent = LaylaApiEvent_onMsg | LaylaApiEvent_onMsgEnd | LaylaApiEvent_onError;
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: 'assistant';
+            content?: string;
+        };
+        finish_reason: 'stop' | null;
+    }>;
+}
+interface ChatCompletion {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: 'assistant';
+            content: string;
+        };
+        finish_reason: 'stop';
+    }>;
+}
+interface ChatCompletionCreateParamsBase {
+    messages: LaylaChatMessage[];
+    /**
+     * Accepted for OpenAI compatibility. The Layla host currently picks the
+     * model itself, so this is only used to populate the `model` field on the
+     * returned objects unless you extend the `send_message` protocol.
+     */
+    model?: string;
+    stream?: boolean;
+    /** Abort the request from the consumer side. */
+    signal?: AbortSignal;
+}
+interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+    stream?: false;
+}
+interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+    stream: true;
+}
+declare class LaylaError extends Error {
+    constructor(message: string);
+}
+declare class LaylaAbortError extends LaylaError {
+    constructor(message?: string);
+}
+declare class LaylaBridgeUnavailableError extends LaylaError {
+    constructor();
+}
+declare global {
+    interface Window {
+        ReactNativeWebView?: {
+            postMessage: (message: string) => void;
+        };
+    }
+}
+/** Implemented by ChatCompletionStream; the bridge drives it. */
+interface StreamSink {
+    handleDelta(delta: string, snapshot: string): void;
+    handleEnd(): void;
+    handleError(err: Error): void;
+    isClosed(): boolean;
+}
+type Listener = (...args: any[]) => void;
+declare class ChatCompletionStream implements StreamSink, AsyncIterable<ChatCompletionChunk> {
+    private readonly id;
+    private readonly created;
+    private readonly model;
+    private buffer;
+    private resolvers;
+    private rejectors;
+    private snapshot;
+    private ended;
+    private closed;
+    private failure;
+    private listeners;
+    private finalDeferred;
+    constructor(model: string);
+    on(event: 'content', listener: (delta: string, snapshot: string) => void): this;
+    on(event: 'chunk', listener: (chunk: ChatCompletionChunk) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    off(event: string, listener: Listener): this;
+    private emit;
+    handleDelta(delta: string, snapshot: string): void;
+    handleEnd(): void;
+    handleError(err: Error): void;
+    isClosed(): boolean;
+    /** Abort from the consumer side. */
+    abort(reason?: unknown): void;
+    next(): Promise<IteratorResult<ChatCompletionChunk>>;
+    /** Breaking out of `for await` aborts the request, like the OpenAI SDK. */
+    return(): Promise<IteratorResult<ChatCompletionChunk>>;
+    [Symbol.asyncIterator](): AsyncIterator<ChatCompletionChunk>;
+    finalChatCompletion(): Promise<ChatCompletion>;
+    finalContent(): Promise<string>;
+    private pushChunk;
+    private drainDone;
+    private drainError;
+    private makeChunk;
+    private buildCompletion;
+}
+declare class Completions {
+    create(body: ChatCompletionCreateParamsNonStreaming): Promise<ChatCompletion>;
+    create(body: ChatCompletionCreateParamsStreaming): Promise<ChatCompletionStream>;
+    /**
+     * OpenAI-style helper: returns the live stream object synchronously (not a
+     * promise), so you can attach `.on(...)` listeners before any token arrives.
+     */
+    stream(body: Omit<ChatCompletionCreateParamsBase, 'stream'>): ChatCompletionStream;
+    private startStream;
+}
+declare class Chat {
+    readonly completions: Completions;
+}
+interface LaylaSDKOptions {
+    /** Reserved for future use (e.g. default model). */
+    model?: string;
+}
+declare class LaylaSDK {
+    readonly chat: Chat;
+    constructor(_options?: LaylaSDKOptions);
+}
+
+export { type ChatCompletion, type ChatCompletionChunk, type ChatCompletionCreateParamsBase, type ChatCompletionCreateParamsNonStreaming, type ChatCompletionCreateParamsStreaming, ChatCompletionStream, LaylaSDK as Layla, LaylaAbortError, type LaylaApiEvent, type LaylaApiEvent_onError, type LaylaApiEvent_onMsg, type LaylaApiEvent_onMsgEnd, type LaylaApiMessage, LaylaBridgeUnavailableError, type LaylaChatMessage, type LaylaChatRole, LaylaError, LaylaSDK, type LaylaSDKOptions, LaylaSDK as default };

package/dist/index.js

@@ -0,0 +1,322 @@
+// src/index.ts
+var LaylaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LaylaError";
+  }
+};
+var LaylaAbortError = class extends LaylaError {
+  constructor(message = "Request was aborted") {
+    super(message);
+    this.name = "LaylaAbortError";
+  }
+};
+var LaylaBridgeUnavailableError = class extends LaylaError {
+  constructor() {
+    super(
+      "Layla bridge unavailable: window.ReactNativeWebView is not present. Make sure this code runs inside the Layla WebView and that the <WebView> has its `onMessage` prop set (that is what injects the bridge)."
+    );
+    this.name = "LaylaBridgeUnavailableError";
+  }
+};
+var Deferred = class {
+  constructor() {
+    this.promise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+};
+var _LaylaBridge = class _LaylaBridge {
+  constructor() {
+    this.queue = [];
+    this.active = null;
+    this.listening = false;
+    this.onWindowMessage = (event) => {
+      const raw = event.data;
+      if (typeof raw !== "string") return;
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      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;
+      }
+    };
+  }
+  static shared() {
+    if (!_LaylaBridge.instance) _LaylaBridge.instance = new _LaylaBridge();
+    return _LaylaBridge.instance;
+  }
+  ensureListening() {
+    if (this.listening || typeof window === "undefined") return;
+    window.addEventListener("message", this.onWindowMessage);
+    this.listening = true;
+  }
+  enqueue(message, sink) {
+    this.ensureListening();
+    this.queue.push({ message, sink });
+    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);
+  }
+  finishActive() {
+    this.active = null;
+    this.pump();
+  }
+  pump() {
+    if (this.active) return;
+    const next = this.queue.shift();
+    if (!next) return;
+    if (next.sink.isClosed()) {
+      this.pump();
+      return;
+    }
+    this.active = next;
+    this.send(next);
+  }
+  send(job) {
+    if (typeof window === "undefined" || !window.ReactNativeWebView) {
+      this.active = null;
+      job.sink.handleError(new LaylaBridgeUnavailableError());
+      this.pump();
+      return;
+    }
+    window.ReactNativeWebView.postMessage(JSON.stringify(job.message));
+  }
+};
+_LaylaBridge.instance = null;
+var LaylaBridge = _LaylaBridge;
+var ChatCompletionStream = class {
+  constructor(model) {
+    this.id = `chatcmpl-layla-${Date.now()}-${Math.floor(
+      Math.random() * 1e6
+    )}`;
+    this.created = Math.floor(Date.now() / 1e3);
+    this.buffer = [];
+    this.resolvers = [];
+    this.rejectors = [];
+    this.snapshot = "";
+    this.ended = false;
+    this.closed = false;
+    this.failure = null;
+    this.listeners = {};
+    this.finalDeferred = new Deferred();
+    this.model = model;
+    this.finalDeferred.promise.catch(() => void 0);
+  }
+  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;
+  }
+  emit(event, ...args) {
+    const ls = this.listeners[event];
+    if (!ls) return;
+    for (const l of ls.slice()) {
+      try {
+        l(...args);
+      } catch {
+      }
+    }
+  }
+  /* ---- StreamSink: driven by the bridge --------------------------------- */
+  handleDelta(delta, snapshot) {
+    if (this.closed) return;
+    this.snapshot = snapshot || this.snapshot + delta;
+    const chunk = this.makeChunk({ content: delta }, null);
+    this.pushChunk(chunk);
+    this.emit("chunk", chunk);
+    if (delta) this.emit("content", delta, this.snapshot);
+  }
+  handleEnd() {
+    if (this.closed) return;
+    const finalChunk = this.makeChunk({}, "stop");
+    this.pushChunk(finalChunk);
+    this.emit("chunk", finalChunk);
+    this.ended = true;
+    this.closed = true;
+    this.drainDone();
+    const completion = this.buildCompletion();
+    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) {
+      return Promise.resolve({ value: this.buffer.shift(), done: false });
+    }
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.ended) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve, reject) => {
+      this.resolvers.push(resolve);
+      this.rejectors.push(reject);
+    });
+  }
+  /** Breaking out of `for await` aborts the request, like the OpenAI SDK. */
+  return() {
+    this.abort(new LaylaAbortError("Stream consumer stopped"));
+    return Promise.resolve({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  /* ---- convenience promises -------------------------------------------- */
+  finalChatCompletion() {
+    return this.finalDeferred.promise;
+  }
+  async finalContent() {
+    const completion = await this.finalDeferred.promise;
+    return completion.choices[0]?.message.content ?? "";
+  }
+  /* ---- internals -------------------------------------------------------- */
+  pushChunk(chunk) {
+    if (this.resolvers.length) {
+      this.resolvers.shift()({ value: chunk, done: false });
+      this.rejectors.shift();
+    } else {
+      this.buffer.push(chunk);
+    }
+  }
+  drainDone() {
+    while (this.resolvers.length) {
+      this.resolvers.shift()({ value: void 0, done: true });
+      this.rejectors.shift();
+    }
+  }
+  drainError(err) {
+    while (this.rejectors.length) {
+      this.rejectors.shift()(err);
+      this.resolvers.shift();
+    }
+  }
+  makeChunk(delta, finish) {
+    return {
+      id: this.id,
+      object: "chat.completion.chunk",
+      created: this.created,
+      model: this.model,
+      choices: [{ index: 0, delta, finish_reason: finish }]
+    };
+  }
+  buildCompletion() {
+    return {
+      id: this.id,
+      object: "chat.completion",
+      created: this.created,
+      model: this.model,
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: this.snapshot },
+          finish_reason: "stop"
+        }
+      ]
+    };
+  }
+};
+var Completions = class {
+  create(body) {
+    const stream = this.startStream(
+      body.messages,
+      body.model ?? "layla",
+      body.signal
+    );
+    if (body.stream) return Promise.resolve(stream);
+    return stream.finalChatCompletion();
+  }
+  /**
+   * OpenAI-style helper: returns the live stream object synchronously (not a
+   * promise), so you can attach `.on(...)` listeners before any token arrives.
+   */
+  stream(body) {
+    return this.startStream(body.messages, body.model ?? "layla", body.signal);
+  }
+  startStream(messages, model, signal) {
+    const stream = new ChatCompletionStream(model);
+    if (signal?.aborted) {
+      queueMicrotask(() => stream.abort(new LaylaAbortError()));
+      return stream;
+    }
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => stream.abort(new LaylaAbortError()),
+        { once: true }
+      );
+    }
+    LaylaBridge.shared().enqueue({ cmd: "send_message", data: messages }, stream);
+    return stream;
+  }
+};
+var Chat = class {
+  constructor() {
+    this.completions = new Completions();
+  }
+};
+var LaylaSDK = class {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(_options = {}) {
+    this.chat = new Chat();
+  }
+};
+var index_default = LaylaSDK;
+export {
+  ChatCompletionStream,
+  LaylaSDK as Layla,
+  LaylaAbortError,
+  LaylaBridgeUnavailableError,
+  LaylaError,
+  LaylaSDK,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "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"
+  }
+}