aione-web 0.0.0-stage → 1.0.1

package/AIOne.d.ts

@@ -0,0 +1,21 @@
+export interface AIOneOptions {
+    workerUrl?: string | URL;
+    runtimeUrl?: string;
+    wasmUrl?: string;
+    threads?: boolean;
+    name?: string;
+}
+
+export default class AIOne {
+    static create(options?: AIOneOptions): Promise<AIOne>;
+
+    loadModel(file: File): Promise<void>;
+    generate(prompt: string, maxTokens?: number): Promise<string>;
+    unloadModel(): Promise<void>;
+    close(): void;
+}
+
+export interface Message {
+    role: "user" | "assistant";
+    content: string;
+}

package/AIOne.js

@@ -0,0 +1,119 @@
+export default class AIOne {
+	static async create(options = {}) {
+		const workerUrl = new URL(
+			options.workerUrl ?? "/aio1-worker.js",
+			globalThis.location?.href ?? import.meta.url
+		);
+
+		if (options.threads) {
+			workerUrl.searchParams.set("threads", "1");
+		}
+
+		if (options.runtimeUrl) {
+			workerUrl.searchParams.set("runtime", options.runtimeUrl);
+		}
+
+		if (options.wasmUrl) {
+			workerUrl.searchParams.set("wasm", options.wasmUrl);
+		}
+
+		if (typeof SharedWorker === "undefined") {
+			throw new Error("SharedWorker is not supported by this browser");
+		}
+
+		const worker = new SharedWorker(workerUrl, {
+			name: options.name ?? "AIOne",
+			type: "classic"
+		});
+
+		worker.onerror = event => {
+			console.error("AIOne SharedWorker error:", event);
+		};
+
+		const client = new AIOne(worker.port);
+		await client.ready();
+
+		return client;
+	}
+
+	constructor(port) {
+		this.port = port;
+		this.nextId = 0;
+		this.pending = new Map();
+
+		this.readyPromise = new Promise((resolve, reject) => {
+			this.resolveReady = resolve;
+			this.rejectReady = reject;
+		});
+
+		this.port.onmessage = ({ data }) => {
+			if (data.type === "ready") {
+				this.resolveReady();
+				return;
+			}
+
+			const pending = this.pending.get(data.id);
+			if (!pending) return;
+
+			this.pending.delete(data.id);
+
+			if (data.error) {
+				pending.reject(new Error(data.error));
+			} else {
+				pending.resolve(data.result);
+			}
+		};
+
+		this.port.onmessageerror = () => {
+			this.rejectReady(new Error("AIOne worker message error"));
+
+			for (const pending of this.pending.values()) {
+				pending.reject(new Error("AIOne worker message error"));
+			}
+
+			this.pending.clear();
+		};
+
+		this.port.start();
+	}
+
+	ready() {
+		return this.readyPromise;
+	}
+
+	call(method, args = {}) {
+		const id = ++this.nextId;
+
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, { resolve, reject });
+
+			this.port.postMessage({
+				id,
+				method,
+				args
+			});
+		});
+	}
+
+	loadModel(file) {
+		return this.call("loadModel", { file });
+	}
+
+	generate(prompt, maxTokens = 512) {
+		return this.call("generate", { prompt, maxTokens });
+	}
+
+	unloadModel() {
+		return this.call("unloadModel");
+	}
+
+	close() {
+		this.port.close();
+
+		for (const pending of this.pending.values()) {
+			pending.reject(new Error("AIOne connection closed"));
+		}
+
+		this.pending.clear();
+	}
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/RPCClient.js

@@ -0,0 +1,55 @@
+export default class RPCClient {
+	constructor(options = {}) {
+		this.workerUrl = options.workerUrl ??
+			new URL("./shared-worker.js", import.meta.url);
+
+		this.pending = new Map();
+		this.nextId = 0;
+	}
+
+	connect() {
+		return new Promise((resolve, reject) => {
+			this.worker = new SharedWorker(this.workerUrl, {
+				type: "module",
+				name: "AIOne"
+			});
+
+			this.port = this.worker.port;
+
+			this.port.onmessage = ({ data }) => {
+				const pending = this.pending.get(data.id);
+				if (!pending) return;
+
+				this.pending.delete(data.id);
+
+				if (data.error) {
+					pending.reject(new Error(data.error));
+				} else {
+					pending.resolve(data.result);
+				}
+			};
+
+			this.port.onmessageerror = () => {
+				reject(new Error("AIOne worker message error"));
+			};
+
+			this.port.start();
+
+			this.call("hello").then(resolve, reject);
+		});
+	}
+
+	call(method, args = {}) {
+		const id = ++this.nextId;
+
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, { resolve, reject });
+
+			this.port.postMessage({
+				id,
+				method,
+				args
+			});
+		});
+	}
+}

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "aione-web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Browser AI inference powered by llama.cpp and WebGPU",
+  "keywords": [
+    "ai",
+    "llm",
+    "llama.cpp",
+    "webgpu",
+    "wasm",
+    "inference",
+    "browser",
+    "sharedworker"
+  ],
+  "homepage": "https://github.com/Iemand005/AIOneWeb#readme",
+  "bugs": {
+    "url": "https://github.com/Iemand005/AIOneWeb/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Iemand005/AIOneWeb.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "./AIOne.js",
+  "module": "./AIOne.js",
+  "types": "./AIOne.d.ts",
+  "exports": {
+    ".": {
+      "types": "./AIOne.d.ts",
+      "import": "./AIOne.js",
+      "default": "./AIOne.js"
+    },
+    "./rpc": {
+      "import": "./RPCClient.js",
+      "default": "./RPCClient.js"
+    },
+    "./runtime": "./worker-runtime.js",
+    "./workerfs-bridge": "./workerfs-bridge.js",
+    "./single": "./build/Release/AIOneWeb.js",
+    "./single/wasm": "./build/Release/AIOneWeb.wasm",
+    "./mt": "./build/Release-mt/AIOneWebMT.js",
+    "./mt/wasm": "./build/Release-mt/AIOneWebMT.wasm",
+    "./AIOneWeb.js": "./build/Release/AIOneWeb.js",
+    "./AIOneWeb.wasm": "./build/Release/AIOneWeb.wasm",
+    "./AIOneWebMT.js": "./build/Release-mt/AIOneWebMT.js",
+    "./AIOneWebMT.wasm": "./build/Release-mt/AIOneWebMT.wasm",
+    "./build/*": "./build/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "AIOne.js",
+    "AIOne.d.ts",
+    "RPCClient.js",
+    "worker-runtime.js",
+    "workerfs-bridge.js",
+    "build/Release/AIOneWeb.js",
+    "build/Release/AIOneWeb.wasm",
+    "build/Release-mt/AIOneWebMT.js",
+    "build/Release-mt/AIOneWebMT.wasm",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/worker-runtime.js

@@ -0,0 +1,124 @@
+let module;
+let session;
+let initializing;
+let mountedFile;
+
+let operationQueue = Promise.resolve();
+
+const WORKER_URL = new URL(self.location.href);
+const SEARCH_PARAMS = WORKER_URL.searchParams;
+const USE_THREADS = SEARCH_PARAMS.get("threads") === "1";
+
+const DEFAULT_RUNTIME_DIR = new URL(
+    USE_THREADS ? "./build/Release-mt/" : "./build/Release/",
+    WORKER_URL
+);
+
+const RUNTIME_URL = SEARCH_PARAMS.get("runtime")
+    ? new URL(SEARCH_PARAMS.get("runtime"), WORKER_URL).href
+    : new URL(
+        USE_THREADS ? "AIOneWebMT.js" : "AIOneWeb.js",
+        DEFAULT_RUNTIME_DIR
+    ).href;
+
+const WASM_URL = SEARCH_PARAMS.get("wasm");
+const HAS_EXTERNAL_RUNTIME = typeof Module !== "undefined";
+
+if (!HAS_EXTERNAL_RUNTIME) {
+    importScripts(RUNTIME_URL);
+}
+
+function locateFile(path) {
+    if (WASM_URL) {
+        return new URL(WASM_URL, WORKER_URL).href;
+    }
+
+    return new URL(path, RUNTIME_URL).href;
+}
+
+async function initialize(file) {
+    if (session) {
+        throw new Error("A model is already loaded");
+    }
+
+    if (module && mountedFile !== file.name) {
+        throw new Error("This runtime is already initialized with another model file");
+    }
+
+    if (!initializing && !module) {
+        initializing = (async () => {
+            const moduleOptions = { workerFile: file };
+
+            if (WASM_URL || !HAS_EXTERNAL_RUNTIME) {
+                moduleOptions.locateFile = locateFile;
+            }
+
+            module = await Module(moduleOptions);
+
+            mountedFile = file.name;
+            session = new module.ModelSession();
+        })();
+
+        try {
+            await initializing;
+        } catch (error) {
+            initializing = undefined;
+            module = undefined;
+            throw error;
+        }
+    } else if (initializing) {
+        await initializing;
+    }
+
+    session.loadModel("/models/" + file.name);
+}
+
+async function invoke(method, args) {
+    switch (method) {
+        case "loadModel":
+            return initialize(args.file);
+
+        case "generate":
+            if (!session?.isLoaded()) {
+                throw new Error("No model is loaded");
+            }
+
+            return session.generate(args.prompt, args.maxTokens ?? 512);
+
+        case "unloadModel":
+            if (session?.isLoaded()) {
+                session.unloadModel();
+            }
+            return;
+
+        default:
+            throw new Error(`Unknown method: ${method}`);
+    }
+}
+
+self.onconnect = event => {
+    const port = event.ports[0];
+
+    port.onmessage = ({ data }) => {
+        const execute = operationQueue.then(() =>
+            invoke(data.method, data.args ?? {})
+        );
+
+        operationQueue = execute.catch(() => {});
+
+        execute.then(
+            result => port.postMessage({
+                id: data.id,
+                result
+            }),
+
+            error => port.postMessage({
+                id: data.id,
+                error: error?.message ?? String(error)
+            })
+        );
+    };
+
+    port.start();
+    port.postMessage({ type: "ready" });
+};

package/workerfs-bridge.js

@@ -0,0 +1,10 @@
+
+Module['preRun'] = Module['preRun'] || [];
+
+Module['preRun'].push(function() {
+    FS.mkdir('/models');
+
+    FS.mount(WORKERFS, {
+        files: [Module['workerFile']]
+    }, '/models');
+});