@gobing-ai/ts-laya-mlx 0.5.1

package/dist/worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-client.d.ts","sourceRoot":"","sources":["../src/worker-client.ts"],"names":[],"mappings":"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"}

package/dist/worker-client.js

@@ -0,0 +1,446 @@
+/**
+ * Process-lifecycle client for the laya JSON-lines worker (task 0076).
+ *
+ * Spawns `worker/laya_worker.py` through ts-runtime's `ProcessExecutor.runStreaming`
+ * (ADR-011/ADR-014 — the only sanctioned spawn seam), awaits the startup handshake
+ * before the first request, correlates responses by id, and enforces two independent
+ * budgets: `startupTimeoutMs` for the one-time weight load, `requestTimeoutMs` for a
+ * single forward pass. The worker is started lazily on the first ask and held for the
+ * client's lifetime; a worker that dies rejects every in-flight call and the next ask
+ * starts a fresh process — never a silent mid-ask restart. Only documented env keys
+ * reach the child, so the injected-env contract (ADR-011) holds across the process
+ * boundary. Protocol reference: docs/design/laya-local-decision-backend.md.
+ */
+import { DecisionAuthError, DecisionBackendError, DecisionConfigError, DecisionConnectionError, DecisionRequestError, DecisionTimeoutError, } from '@gobing-ai/ts-ai-runner';
+import { joinPath, nodeBunFactory } from '@gobing-ai/ts-runtime';
+/** Environment keys this package may pass to the child process — the full allowlist. */
+const FORWARDED_ENV_KEYS = ['LAYA_MODEL_ID', 'LAYA_MODEL_PATH', 'LAYA_CACHE_DIR', 'LAYA_PYTHON', 'HF_TOKEN'];
+/** How many trailing stderr bytes to keep for exit-failure messages. */
+const STDERR_TAIL_LIMIT = 2000;
+/** Grace window for the exit event once stdout closes, so pending calls reject with the exit-informed error. */
+const STREAM_CLOSE_GRACE_MS = 250;
+/**
+ * Project the injected environment onto the child allowlist. Everything absent from
+ * `FORWARDED_ENV_KEYS` is dropped, so the parent environment is never inherited
+ * wholesale and the child gets exactly the documented keys that are set.
+ */
+export function resolveForwardedEnv(env) {
+    const forwarded = {};
+    if (!env)
+        return forwarded;
+    for (const key of FORWARDED_ENV_KEYS) {
+        const value = env[key];
+        if (value !== undefined)
+            forwarded[key] = value;
+    }
+    return forwarded;
+}
+/**
+ * Validate host platform prerequisites for `@gobing-ai/ts-laya-mlx`.
+ * Throws {@link DecisionConfigError} if the platform is not Apple Silicon macOS.
+ */
+export function validateHostPrerequisites(platform = process.platform, arch = process.arch) {
+    if (platform !== 'darwin' || arch !== 'arm64') {
+        throw new DecisionConfigError(`laya-mlx requires macOS on Apple Silicon (darwin arm64); current platform is '${platform} ${arch}'`, 'PLATFORM');
+    }
+}
+function hasNonFiniteValues(obj) {
+    if (typeof obj === 'number') {
+        return !Number.isFinite(obj);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        for (const val of Object.values(obj)) {
+            if (hasNonFiniteValues(val))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Map worker-reported error kinds and messages onto the decision taxonomy (design: Errors table, task 0077).
+ */
+export function translateWorkerError(kind, message) {
+    const lower = message.toLowerCase();
+    // Credential/auth failures during artifact resolution (0077 R6)
+    if (lower.includes('401') ||
+        lower.includes('unauthorized') ||
+        lower.includes('403') ||
+        lower.includes('forbidden') ||
+        lower.includes('gated repo') ||
+        lower.includes('hf_token') ||
+        lower.includes('invalid credentials')) {
+        const status = lower.includes('403') || lower.includes('forbidden') ? 403 : 401;
+        return new DecisionAuthError(`laya artifact resolution failed: ${message}`, status);
+    }
+    // Transport/connection failures during artifact resolution (0077 R6)
+    if (lower.includes('connectionerror') ||
+        lower.includes('connection refused') ||
+        lower.includes('name resolution') ||
+        lower.includes('nameresolutionerror') ||
+        lower.includes('network is unreachable') ||
+        lower.includes('could not connect') ||
+        lower.includes('transport')) {
+        return new DecisionConnectionError(`laya artifact resolution failed: ${message}`);
+    }
+    // Missing runtime (0077 R2)
+    if (lower.includes('no module named') || lower.includes('laya_mlx') || lower.includes('laya-mlx')) {
+        return new DecisionConfigError(`laya-mlx runtime is not importable: ${message}; install with 'pip install laya-mlx'`, 'LAYA_PYTHON');
+    }
+    // Non-finite output (0077 R5)
+    if (lower.includes('non-finite') ||
+        lower.includes('floatingpointerror') ||
+        lower.includes('nan') ||
+        lower.includes('infinity')) {
+        return new DecisionBackendError(`laya worker non-finite output: ${message}`, undefined);
+    }
+    switch (kind) {
+        case 'config':
+            return new DecisionConfigError(`laya worker rejected its configuration: ${message}`, 'laya-worker');
+        case 'request':
+            return new DecisionRequestError(`laya worker rejected the request: ${message}`, undefined, message);
+        default:
+            return new DecisionBackendError(`laya worker backend failure: ${message}`, undefined);
+    }
+}
+/** Map a worker-reported error kind onto the decision taxonomy (design: Errors table). */
+function toWorkerError(kind, message) {
+    return translateWorkerError(kind, message);
+}
+/**
+ * A started worker process plus its line pump, pending-request map, handshake
+ * race, and exit watcher. The pump owns the stdout stream exclusively: the first
+ * line settles the handshake, every later line dispatches by id.
+ */
+class WorkerHandle {
+    proc;
+    handshake;
+    requestTimeoutMs;
+    pending = new Map();
+    nextRequestId = 1;
+    alive = true;
+    stderrTail = '';
+    handshakeSettled = false;
+    handshakeTimer = null;
+    handshakeResolve = null;
+    handshakeReject = null;
+    streamCloseTimer = null;
+    constructor(proc, requestTimeoutMs, startupTimeoutMs) {
+        this.proc = proc;
+        this.requestTimeoutMs = requestTimeoutMs;
+        this.handshake = new Promise((resolve, reject) => {
+            this.handshakeResolve = resolve;
+            this.handshakeReject = reject;
+        });
+        this.handshakeTimer = setTimeout(() => {
+            this.failHandshake(new DecisionTimeoutError(`laya worker did not emit its handshake within startupTimeoutMs (${startupTimeoutMs})`, startupTimeoutMs));
+        }, startupTimeoutMs);
+        if (proc.stdout !== null)
+            this.pump(proc.stdout);
+        if (proc.stderr !== null)
+            this.collectStderr(proc.stderr);
+        void proc.exited.then((code) => {
+            this.alive = false;
+            this.failHandshake(this.exitError(code));
+            this.failAll(this.exitError(code));
+        });
+    }
+    /** Reject everything in flight; the map clear makes repeated calls harmless. */
+    failAll(error) {
+        this.alive = false;
+        for (const entry of this.pending.values()) {
+            clearTimeout(entry.timer);
+            entry.reject(error);
+        }
+        this.pending.clear();
+    }
+    /** Close stdin for a graceful EOF exit. */
+    end() {
+        try {
+            this.proc.endStdin();
+        }
+        catch {
+            // Already dead — the exit watcher owns failure propagation from here.
+        }
+    }
+    /** Terminate a worker that must not keep running (startup failure). */
+    kill() {
+        try {
+            this.proc.kill();
+        }
+        catch {
+            // Already dead — the exit watcher owns failure propagation from here.
+        }
+    }
+    get isAlive() {
+        return this.alive;
+    }
+    /**
+     * Register a pending entry under the request timeout and return its correlation
+     * id. Registered before the write so the exit watcher covers the send window.
+     */
+    armRequest(resolve, reject) {
+        const id = String(this.nextRequestId++);
+        const requestTimeoutMs = this.requestTimeoutMs;
+        const timer = setTimeout(() => {
+            // Reject this request only; the stream keeps running and the late
+            // response is dropped by id when it arrives (no queue corruption).
+            this.pending.delete(id);
+            reject(new DecisionTimeoutError(`laya worker request ${id} exceeded requestTimeoutMs (${requestTimeoutMs})`, requestTimeoutMs));
+        }, requestTimeoutMs);
+        this.pending.set(id, { resolve, reject, timer });
+        return id;
+    }
+    exitError(code) {
+        const tail = this.stderrTail.length > 0 ? `: ${this.stderrTail}` : '';
+        const raw = `${this.stderrTail} (code ${code ?? 'unknown'})`;
+        if (raw.includes('No module named') || raw.includes('laya_mlx')) {
+            return new DecisionConfigError(`laya-mlx runtime is not importable: ${raw}; install with 'pip install laya-mlx'`, 'LAYA_PYTHON');
+        }
+        return new DecisionBackendError(`laya worker exited unexpectedly (code ${code ?? 'unknown'})${tail}`, undefined);
+    }
+    failHandshake(error) {
+        if (this.handshakeSettled)
+            return;
+        this.handshakeSettled = true;
+        if (this.handshakeTimer !== null)
+            clearTimeout(this.handshakeTimer);
+        this.handshakeReject?.(error);
+    }
+    /** Read stdout as UTF-8 JSON Lines; first line settles the handshake, the rest dispatch by id. */
+    pump(stream) {
+        const decoder = new TextDecoder();
+        let buffer = '';
+        void (async () => {
+            for await (const chunk of stream) {
+                buffer += decoder.decode(chunk, { stream: true });
+                let newlineAt = buffer.indexOf('\n');
+                while (newlineAt !== -1) {
+                    this.onLine(buffer.slice(0, newlineAt));
+                    buffer = buffer.slice(newlineAt + 1);
+                    newlineAt = buffer.indexOf('\n');
+                }
+            }
+            buffer += decoder.decode();
+            if (buffer.trim().length > 0)
+                this.onLine(buffer);
+            this.onStreamClosed();
+        })().catch(() => {
+            this.failAll(new DecisionBackendError('laya worker output stream failed', undefined));
+        });
+    }
+    /**
+     * Stdout closed: a dead worker's pipes drain before its exit event resolves, so
+     * defer to the exit watcher — pending calls must reject with the exit-informed
+     * error (exit code + stderr tail), not a generic stream close. The grace timer
+     * bounds the wait for a worker that closed its stream but kept running; those
+     * calls fall back to the close rejection instead of hanging to their timeouts.
+     */
+    onStreamClosed() {
+        this.streamCloseTimer = setTimeout(() => {
+            this.streamCloseTimer = null;
+            this.failAll(new DecisionBackendError('laya worker closed its output stream', undefined));
+        }, STREAM_CLOSE_GRACE_MS);
+        void this.proc.exited.then((code) => {
+            if (this.streamCloseTimer !== null) {
+                clearTimeout(this.streamCloseTimer);
+                this.streamCloseTimer = null;
+            }
+            this.failAll(this.exitError(code));
+        });
+    }
+    onLine(line) {
+        if (!this.handshakeSettled) {
+            this.settleHandshake(line);
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            // Stream framing is broken — no pending request can trust what follows.
+            this.failAll(new DecisionBackendError(`laya worker emitted an unparseable line: ${line.slice(0, 200)}`, undefined));
+            this.kill();
+            return;
+        }
+        if (parsed.id === undefined)
+            return; // stray line without correlation — dropped by design
+        const entry = this.pending.get(String(parsed.id));
+        if (entry === undefined)
+            return; // late response for an already-rejected request
+        this.pending.delete(String(parsed.id));
+        clearTimeout(entry.timer);
+        if (parsed.ok === true && parsed.result !== undefined) {
+            if (hasNonFiniteValues(parsed.result.answers)) {
+                entry.reject(new DecisionBackendError("laya worker returned non-finite model outputs; retry with dtype='float32'", undefined));
+                return;
+            }
+            entry.resolve(parsed.result);
+            return;
+        }
+        if (parsed.ok === false) {
+            entry.reject(toWorkerError(parsed.error?.kind, parsed.error?.message ?? 'unknown worker error'));
+            return;
+        }
+        entry.reject(new DecisionBackendError(`laya worker sent a malformed response for request ${String(parsed.id)}`, undefined));
+    }
+    /** First stdout line: validate the handshake envelope and settle the startup race. */
+    settleHandshake(line) {
+        if (this.handshakeSettled)
+            return; // the timeout or the exit watcher won the race
+        this.handshakeSettled = true;
+        if (this.handshakeTimer !== null)
+            clearTimeout(this.handshakeTimer);
+        let handshake;
+        try {
+            handshake = JSON.parse(line);
+        }
+        catch {
+            this.handshakeReject?.(new DecisionBackendError(`laya worker handshake was not JSON: ${line.slice(0, 200)}`, undefined));
+            return;
+        }
+        if (handshake.ready === true) {
+            this.handshakeResolve?.(handshake);
+            return;
+        }
+        this.handshakeReject?.(toWorkerError(handshake.error?.kind ?? 'config', handshake.error?.message ?? 'worker reported it was not ready'));
+    }
+    /** Drain stderr so a chatty worker cannot block, keeping a tail for exit diagnostics. */
+    collectStderr(stream) {
+        const decoder = new TextDecoder();
+        void (async () => {
+            for await (const chunk of stream) {
+                this.stderrTail = `${this.stderrTail}${decoder.decode(chunk, { stream: true })}`.slice(-STDERR_TAIL_LIMIT);
+            }
+        })().catch(() => {
+            // Stderr diagnostics are best-effort only.
+        });
+    }
+}
+/**
+ * TypeScript half of the laya process bridge: start the Python worker lazily,
+ * hold it warm for the client's lifetime, and serve serialized asks with
+ * id-correlated, timeout-bounded responses.
+ */
+export class LayaWorkerClient {
+    pythonPath;
+    args;
+    cwd;
+    startupTimeoutMs;
+    requestTimeoutMs;
+    forwardedEnv;
+    executor;
+    worker = null;
+    chain = Promise.resolve();
+    disposed = false;
+    constructor(options = {}, executor = nodeBunFactory.createProcessExecutor()) {
+        validateHostPrerequisites(options.platform, options.arch);
+        const packageRoot = joinPath(import.meta.dir, '..');
+        this.pythonPath = options.pythonPath ?? options.env?.LAYA_PYTHON ?? 'python3';
+        this.cwd = options.cwd ?? packageRoot;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? 120_000;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+        this.forwardedEnv = resolveForwardedEnv(options.env);
+        this.executor = executor;
+        this.args = [options.workerScript ?? joinPath(packageRoot, 'worker', 'laya_worker.py')];
+        this.args.push('--module', options.module ?? 'laya_mlx');
+        const resolvedModelPath = options.modelPath ?? options.env?.LAYA_MODEL_PATH;
+        const resolvedCacheDir = options.cacheDir ?? options.env?.LAYA_CACHE_DIR;
+        const resolvedModelId = options.modelId ?? options.env?.LAYA_MODEL_ID ?? 'convaiinnovations/laya-multilingual';
+        if (resolvedModelPath !== undefined) {
+            this.args.push('--model-path', resolvedModelPath);
+        }
+        else {
+            this.args.push('--model', resolvedModelId);
+        }
+        if (options.revision !== undefined)
+            this.args.push('--revision', options.revision);
+        this.args.push('--dtype', options.dtype ?? 'float16');
+        this.args.push('--batch-size', String(options.batchSize ?? 16));
+        if (resolvedCacheDir !== undefined)
+            this.args.push('--cache-dir', resolvedCacheDir);
+    }
+    /**
+     * Ask one batch of worker-format questions. Requests are serialized — the
+     * worker serves one request at a time and batching happens inside a single
+     * request — and the worker spawns lazily on the first call, so the weight
+     * load is paid once per client.
+     */
+    ask(state, questions) {
+        const run = this.chain.then(() => this.dispatch(state, questions));
+        this.chain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** Close the worker; safe to call repeatedly. In-flight calls reject through the exit watcher. */
+    dispose() {
+        this.disposed = true;
+        const worker = this.worker;
+        this.worker = null;
+        worker?.end();
+    }
+    async dispatch(state, questions) {
+        if (this.disposed)
+            throw new DecisionBackendError('laya worker client has been disposed', undefined);
+        const worker = await this.ensureWorker();
+        return new Promise((resolve, reject) => {
+            const id = worker.armRequest(resolve, reject);
+            try {
+                worker.proc.writeStdin(`${JSON.stringify({ id, state, questions })}\n`);
+            }
+            catch (cause) {
+                reject(new DecisionBackendError('laya worker rejected the request line', undefined, { cause }));
+                return;
+            }
+            if (!worker.isAlive) {
+                // The exit watcher raced the write; fail now instead of at the timeout.
+                worker.failAll(new DecisionBackendError('laya worker exited before the request could be sent', undefined));
+            }
+        });
+    }
+    async ensureWorker() {
+        if (this.worker?.isAlive)
+            return this.worker;
+        this.worker = null;
+        const worker = this.spawn();
+        try {
+            await worker.handshake;
+        }
+        catch (error) {
+            // Startup failed: nothing is in flight, so terminate and surface the
+            // error. The next ask starts fresh rather than reusing a dead handle.
+            worker.kill();
+            throw error;
+        }
+        if (this.disposed) {
+            // dispose() raced the startup handshake — the worker must not outlive
+            // a disposed client.
+            worker.kill();
+            throw new DecisionBackendError('laya worker client has been disposed', undefined);
+        }
+        this.worker = worker;
+        return worker;
+    }
+    spawn() {
+        let proc;
+        try {
+            proc = this.executor.runStreaming({
+                command: this.pythonPath,
+                args: this.args,
+                env: this.forwardedEnv,
+                envMode: 'replace',
+                label: 'laya-worker',
+                cwd: this.cwd,
+            });
+        }
+        catch (cause) {
+            throw new DecisionConfigError(`Python interpreter '${this.pythonPath}' is missing or not executable; install Python 3.10+ (e.g. via 'brew install python@3.11') or set LAYA_PYTHON`, 'LAYA_PYTHON', { cause });
+        }
+        const handle = new WorkerHandle(proc, this.requestTimeoutMs, this.startupTimeoutMs);
+        void proc.exited.then(() => {
+            if (this.worker === handle) {
+                this.worker = null;
+            }
+        });
+        return handle;
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@gobing-ai/ts-laya-mlx",
+    "version": "0.5.1",
+    "description": "@gobing-ai/ts-laya-mlx — Local Laya decision backend driving the vendored MLX runtime over a process bridge.",
+    "keywords": [
+        "typescript",
+        "ai",
+        "decision",
+        "mlx",
+        "laya",
+        "local"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gobing-ai/ts-libs.git",
+        "directory": "packages/laya-mlx"
+    },
+    "author": "Robin Min <minlongbing@gmail.com>",
+    "contributors": [
+        "Robin Min <minlongbing@gmail.com>"
+    ],
+    "type": "module",
+    "private": false,
+    "sideEffects": false,
+    "license": "Apache-2.0",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "worker",
+        "README.md",
+        "LICENSE",
+        "NOTICE"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json && bun ../../scripts/builder.ts fix-dist-esm-extensions dist",
+        "test": "NODE_ENV=test bun test --coverage --coverage-dir=.coverage --reporter=dots",
+        "test:full": "NODE_ENV=test bun test --update-snapshots --coverage --coverage-dir=.coverage",
+        "typecheck": "tsc --noEmit",
+        "lint": "biome check . && bun run typecheck",
+        "format": "biome check . --write",
+        "parity": "bun scripts/full-parity.ts",
+        "check": "bun run lint && bun run test",
+        "prepublishOnly": "bun run build",
+        "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-laya-mlx-v<version> && git push --tags' && exit 1"
+    },
+    "dependencies": {
+        "@gobing-ai/ts-ai-runner": "workspace:*",
+        "@gobing-ai/ts-runtime": "workspace:*"
+    },
+    "devDependencies": {
+        "@types/bun": "1.3.14"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}