pi-laya-mlx 0.1.0

package/README.md

@@ -0,0 +1,154 @@
+# pi-laya-mlx ⚡
+
+> **Fast, local semantic router & model optimizer for Pi coding agent using Apple Silicon MLX.**
+
+`pi-laya-mlx` classifies developer prompt intent locally in **sub-15ms** using dense multilingual sentence embeddings, then dynamically routes each prompt to the optimal model and thinking tier (e.g., lightweight models for simple chat/file exploration, high-reasoning frontier models for deep architecture and hard coding tasks).
+
+---
+
+## 💻 Hardware & Platform Support
+
+| Platform | Hardware Target | Acceleration | Expected Latency |
+|---|---|---|---|
+| **macOS** | Apple Silicon (M1 / M2 / M3 / M4) | **Metal GPU Native (Zero-Copy)** | **~5–15 ms** |
+| **Linux (x86_64 / ARM64 / Asahi)** | Generic CPU / Apple CPU | **CPU Fallback (`mlx[cpu]`)** | **~40–120 ms** |
+
+> ⚠️ **Note on Linux / Asahi Linux:** Apple MLX hardware acceleration depends on Apple's proprietary Metal framework (macOS only). On Linux, it runs in **CPU-only mode**, which is functional but slower than macOS Metal execution.
+
+---
+
+## 📦 Installation
+
+### 1. Install as Pi Package
+
+Install directly from GitHub or npm:
+
+```bash
+# From Git repository:
+pi install git:github.com/<your-username>/pi-laya-mlx
+
+# Or from npm:
+pi install npm:pi-laya-mlx
+
+# Or locally during development:
+pi install ./pi-laya-mlx
+```
+
+### 2. Setup Daemon Environment
+
+In the package `daemon` directory (or globally), install the Python dependencies:
+
+```bash
+cd daemon
+
+# Recommended: using uv (ultra fast)
+uv venv
+uv pip install -r requirements.txt
+
+# Or using standard pip:
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+---
+
+## 🚀 CLI Usage (`laya`)
+
+`pi-laya-mlx` includes a convenient CLI binary:
+
+```bash
+# Check daemon health, active model, and anchor counts
+laya status
+
+# Start daemon in background (port 4141)
+laya start
+
+# Stop the running daemon
+laya stop
+
+# Restart the daemon
+laya restart
+
+# Hot-reload anchor embeddings after editing anchors.json (<50ms)
+laya reload
+
+# View recent prediction logs & confidence scores
+laya logs -n 20
+
+# Record a misclassification flag for tuning
+laya flag CODING_STANDARD "tolong implementasikan fungsi ini"
+
+# Initialize default ~/.pi/agent/laya-router.json config
+laya init
+```
+
+---
+
+## ⚡ Pi Extension Commands & Shortcuts
+
+Inside your Pi session:
+
+- **Toggle router on/off**: `/laya` or press `Ctrl+Shift+J` / `Alt+J`
+- **Check status**: `/laya status`
+- **View prediction logs**: `/laya logs`
+- **Flag misclassification**: `/laya flag [chat|coding|review|explore|arch]`
+- **Tune anchors**: `/skill:laya-tune`
+
+---
+
+## ⚙️ Configuration (`~/.pi/agent/laya-router.json`)
+
+```json
+{
+  "enabled": true,
+  "endpoint": "http://127.0.0.1:4141/predict",
+  "threshold": 0.25,
+  "routes": {
+    "CHAT_OR_TRIVIAL": {
+      "provider": "anthropic",
+      "model": "claude-haiku-4-5",
+      "thinking": "off",
+      "description": "General casual chat, short responses, confirmations, trivial queries"
+    },
+    "RESEARCH_AND_EXPLORE": {
+      "provider": "anthropic",
+      "model": "claude-haiku-4-5",
+      "thinking": "low",
+      "description": "File search, code exploration, grep lookups, error investigations"
+    },
+    "CODING_STANDARD": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4-6",
+      "thinking": "low",
+      "description": "Standard coding tasks, bug fixes, feature implementation, refactoring"
+    },
+    "CODE_REVIEW": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4-6",
+      "thinking": "medium",
+      "description": "Code reviews, diff analysis, security audits, pre-push checks"
+    },
+    "HARD_ARCHITECTURE": {
+      "provider": "anthropic",
+      "model": "claude-opus-4-6",
+      "thinking": "high",
+      "description": "Complex system architecture, tricky debugging, hard distributed systems"
+    }
+  }
+}
+```
+
+---
+
+## 🎯 Continuous Tuning
+
+When Laya misclassifies a prompt:
+1. Run `/laya flag <category>` (or `laya flag` in CLI) to log the prompt.
+2. Run `/skill:laya-tune` in Pi. An isolated background agent will analyze the flagged entries, add new anchor exemplars to `anchors.json`, and hot-reload the daemon instantly via `/reload-anchors` without restarting the server.
+
+---
+
+## 📄 License
+
+MIT

package/bin/laya.mjs

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PKG_ROOT = path.resolve(__dirname, "..");
+const DAEMON_DIR = path.join(PKG_ROOT, "daemon");
+
+const PORT = process.env.LAYA_PORT || "4141";
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const USER_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "laya-router.json");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+async function checkHealth(timeoutMs = 1200) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(`${BASE_URL}/health`, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return { ok: false, status: res.status };
+    const data = await res.json();
+    return { ok: true, data };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function getDaemonPid() {
+  try {
+    const out = execSync(`lsof -ti:${PORT}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const pids = out.trim().split("\n").filter(Boolean);
+    return pids.length > 0 ? pids[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+async function cmdStatus() {
+  console.log(`\n${c.bold}⚡ Laya Local Router Status${c.reset}`);
+  console.log(`${c.dim}Endpoint: ${BASE_URL}${c.reset}\n`);
+
+  const pid = getDaemonPid();
+  const health = await checkHealth();
+
+  if (health.ok) {
+    console.log(`  State:      ${c.green}● RUNNING${c.reset} ${pid ? `(PID: ${pid})` : ""}`);
+    console.log(`  Model:      ${c.cyan}${health.data?.model || "default"}${c.reset}`);
+    console.log(`  Engine:     ${health.data?.engine || "laya-mlx"}`);
+    
+    if (health.data?.anchors_count) {
+      console.log(`\n  ${c.bold}Active Anchor Exemplars:${c.reset}`);
+      for (const [cat, count] of Object.entries(health.data.anchors_count)) {
+        console.log(`    • ${cat.padEnd(22)} : ${c.yellow}${count}${c.reset} exemplars`);
+      }
+    }
+  } else {
+    console.log(`  State:      ${c.red}○ STOPPED${c.reset}`);
+    console.log(`  ${c.dim}Run 'laya start' to launch daemon.${c.reset}`);
+  }
+
+  // Config check
+  console.log(`\n  ${c.bold}Pi Extension Config:${c.reset}`);
+  if (fs.existsSync(USER_CONFIG_PATH)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(USER_CONFIG_PATH, "utf8"));
+      console.log(`    • File:     ${USER_CONFIG_PATH}`);
+      console.log(`    • Enabled:  ${cfg.enabled ? `${c.green}YES${c.reset}` : `${c.yellow}NO${c.reset}`}`);
+      console.log(`    • Threshold: ${cfg.threshold ?? 0.25}`);
+      console.log(`    • Routes:   ${Object.keys(cfg.routes || {}).join(", ")}`);
+    } catch {
+      console.log(`    • Status:   ${c.red}Invalid JSON in ${USER_CONFIG_PATH}${c.reset}`);
+    }
+  } else {
+    console.log(`    • Status:   ${c.dim}Not configured yet. Run 'laya init'${c.reset}`);
+  }
+  console.log();
+}
+
+async function cmdStart() {
+  const health = await checkHealth(500);
+  if (health.ok) {
+    console.log(`${c.yellow}[Laya] Daemon is already running on port ${PORT}.${c.reset}`);
+    return;
+  }
+
+  console.log(`${c.cyan}[Laya] Starting daemon on port ${PORT}...${c.reset}`);
+
+  let runCmd = "uv";
+  let runArgs = ["run", "server.py"];
+
+  // Fallback to python3 if uv is not installed
+  try {
+    execSync("which uv", { stdio: "ignore" });
+  } catch {
+    runCmd = "python3";
+    runArgs = ["server.py"];
+  }
+
+  const logFile = path.join(DAEMON_DIR, "server.log");
+  const outStream = fs.openSync(logFile, "a");
+  const errStream = fs.openSync(logFile, "a");
+
+  const child = spawn(runCmd, runArgs, {
+    cwd: DAEMON_DIR,
+    detached: true,
+    stdio: ["ignore", outStream, errStream],
+    env: { ...process.env, LAYA_PORT: PORT },
+  });
+
+  child.unref();
+
+  process.stdout.write(`Waiting for model load (${runCmd})... `);
+  for (let i = 0; i < 35; i++) {
+    await new Promise((r) => setTimeout(r, 1000));
+    const h = await checkHealth(800);
+    if (h.ok) {
+      console.log(`${c.green}Ready!${c.reset}`);
+      console.log(`${c.dim}Logs written to: ${logFile}${c.reset}`);
+      return;
+    }
+    process.stdout.write(".");
+  }
+
+  console.log(`\n${c.red}[Laya] Timeout waiting for daemon startup. Check ${logFile}${c.reset}`);
+  process.exit(1);
+}
+
+async function cmdStop() {
+  const pid = getDaemonPid();
+  if (!pid) {
+    console.log(`${c.yellow}[Laya] No running daemon found on port ${PORT}.${c.reset}`);
+    return;
+  }
+
+  console.log(`${c.cyan}[Laya] Stopping daemon (PID: ${pid})...${c.reset}`);
+  try {
+    process.kill(Number(pid), "SIGTERM");
+  } catch {
+    try {
+      execSync(`kill -9 ${pid}`, { stdio: "ignore" });
+    } catch {}
+  }
+
+  await new Promise((r) => setTimeout(r, 1000));
+  const pidAfter = getDaemonPid();
+  if (pidAfter) {
+    try {
+      execSync(`kill -9 ${pidAfter}`, { stdio: "ignore" });
+    } catch {}
+  }
+
+  console.log(`${c.green}[Laya] Daemon stopped successfully.${c.reset}`);
+}
+
+async function cmdReload() {
+  console.log(`${c.cyan}[Laya] Reloading anchor embeddings...${c.reset}`);
+  try {
+    const res = await fetch(`${BASE_URL}/reload-anchors`, { method: "POST" });
+    if (!res.ok) {
+      console.error(`${c.red}[Laya] Failed to reload anchors (HTTP ${res.status})${c.reset}`);
+      return;
+    }
+    const data = await res.json();
+    console.log(`${c.green}✓ Anchors reloaded in ${data.reloaded_ms}ms!${c.reset}`);
+    if (data.counts) {
+      for (const [cat, count] of Object.entries(data.counts)) {
+        console.log(`  • ${cat.padEnd(22)}: ${count} exemplars`);
+      }
+    }
+  } catch (err) {
+    console.error(`${c.red}[Laya] Error connecting to daemon: ${err.message}${c.reset}`);
+  }
+}
+
+async function cmdLogs(limit = 15) {
+  try {
+    const res = await fetch(`${BASE_URL}/logs?limit=${limit}`);
+    if (!res.ok) {
+      console.error(`${c.red}[Laya] Failed to fetch logs (HTTP ${res.status})${c.reset}`);
+      return;
+    }
+    const data = await res.json();
+    if (!data.logs || data.logs.length === 0) {
+      console.log(`${c.dim}[Laya] No prediction logs recorded yet.${c.reset}`);
+      return;
+    }
+
+    console.log(`\n${c.bold}⚡ Recent Laya Prediction Logs (Latest ${data.logs.length}):${c.reset}\n`);
+    for (const item of data.logs) {
+      const timeStr = item.timestamp?.split("T")[1]?.slice(0, 8) || "";
+      const conf = Math.round((item.confidence || 0) * 100);
+      const prompt = item.prompt?.length > 45 ? item.prompt.slice(0, 42) + "..." : item.prompt;
+      console.log(
+        `  ${c.dim}[${timeStr}]${c.reset} ${c.green}${item.choice?.padEnd(20)}${c.reset} (${conf}% conf) [${item.latency_ms}ms] <- "${prompt}"`
+      );
+    }
+    console.log();
+  } catch (err) {
+    console.error(`${c.red}[Laya] Error fetching logs: ${err.message}${c.reset}`);
+  }
+}
+
+async function cmdFlag(cat, prompt) {
+  if (!cat || !prompt) {
+    console.log(`Usage: laya flag <category> <prompt text>`);
+    console.log(`Categories: CHAT_OR_TRIVIAL, RESEARCH_AND_EXPLORE, CODING_STANDARD, CODE_REVIEW, HARD_ARCHITECTURE`);
+    return;
+  }
+
+  try {
+    const res = await fetch(`${BASE_URL}/corrections`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt, target: cat }),
+    });
+    if (!res.ok) {
+      console.error(`${c.red}[Laya] Failed to record correction (HTTP ${res.status})${c.reset}`);
+      return;
+    }
+    console.log(`${c.green}✓ Flagged prompt saved to corrections.jsonl → ${cat}${c.reset}`);
+    console.log(`Run '/skill:laya-tune' inside Pi to optimize anchors.`);
+  } catch (err) {
+    console.error(`${c.red}[Laya] Error recording correction: ${err.message}${c.reset}`);
+  }
+}
+
+function cmdInit() {
+  const targetDir = path.dirname(USER_CONFIG_PATH);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  if (fs.existsSync(USER_CONFIG_PATH)) {
+    console.log(`${c.yellow}[Laya] Config already exists at: ${USER_CONFIG_PATH}${c.reset}`);
+    return;
+  }
+
+  const sampleConfig = {
+    enabled: true,
+    endpoint: "http://127.0.0.1:4141/predict",
+    threshold: 0.25,
+    routes: {
+      CHAT_OR_TRIVIAL: {
+        provider: "anthropic",
+        model: "claude-haiku-4-5",
+        thinking: "off",
+        description: "General casual chat, short responses, simple confirmations, trivial queries",
+      },
+      RESEARCH_AND_EXPLORE: {
+        provider: "anthropic",
+        model: "claude-haiku-4-5",
+        thinking: "low",
+        description: "File search, code exploration, grep lookups, error investigations, planning",
+      },
+      CODING_STANDARD: {
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        thinking: "low",
+        description: "Standard coding tasks, bug fixes, feature implementation, refactoring, unit tests",
+      },
+      CODE_REVIEW: {
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        thinking: "medium",
+        description: "Code reviews, diff analysis, security audits, pre-push checks",
+      },
+      HARD_ARCHITECTURE: {
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+        thinking: "high",
+        description: "Complex system architecture, tricky debugging, hard distributed systems problems",
+      },
+    },
+  };
+
+  fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(sampleConfig, null, 2), "utf8");
+  console.log(`${c.green}✓ Created default config at: ${USER_CONFIG_PATH}${c.reset}`);
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}⚡ Laya MLX CLI${c.reset} — Local semantic router for Pi coding agent
+
+${c.bold}USAGE:${c.reset}
+  laya <command> [options]
+
+${c.bold}COMMANDS:${c.reset}
+  ${c.cyan}status${c.reset}              Check daemon health, model, active anchors, and config
+  ${c.cyan}start${c.reset}               Start the Laya daemon in background on port ${PORT}
+  ${c.cyan}stop${c.reset}                Stop the running Laya daemon
+  ${c.cyan}restart${c.reset}             Restart the Laya daemon
+  ${c.cyan}reload${c.reset}              Hot-reload anchors.json embeddings without restart
+  ${c.cyan}logs${c.reset} [-n <limit>]   Display recent semantic prediction logs
+  ${c.cyan}flag${c.reset} <cat> <text>   Record a misclassification correction for tuning
+  ${c.cyan}init${c.reset}                Create default ~/.pi/agent/laya-router.json config
+  ${c.cyan}help${c.reset}                Show this help message
+
+${c.bold}ENVIRONMENT VARIABLES:${c.reset}
+  LAYA_PORT           Port for Laya daemon (default: 4141)
+  LAYA_MODEL          Hugging Face model ID (default: aac6fef/laya-multilingual-mlx)
+`);
+}
+
+const [,, cmd, ...args] = process.argv;
+
+switch (cmd) {
+  case "status":
+    await cmdStatus();
+    break;
+  case "start":
+    await cmdStart();
+    break;
+  case "stop":
+    await cmdStop();
+    break;
+  case "restart":
+    await cmdStop();
+    await cmdStart();
+    break;
+  case "reload":
+    await cmdReload();
+    break;
+  case "logs":
+  case "log": {
+    const limitIdx = args.indexOf("-n");
+    const limit = limitIdx !== -1 && args[limitIdx + 1] ? Number(args[limitIdx + 1]) : 15;
+    await cmdLogs(limit);
+    break;
+  }
+  case "flag":
+  case "correct":
+    await cmdFlag(args[0], args.slice(1).join(" "));
+    break;
+  case "init":
+    cmdInit();
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    printHelp();
+    break;
+  default:
+    console.error(`${c.red}Unknown command: ${cmd}${c.reset}`);
+    printHelp();
+    process.exit(1);
+}

package/daemon/anchors.json

@@ -0,0 +1,111 @@
+{
+  "CHAT_OR_TRIVIAL": [
+    "hello how are you today",
+    "thanks, looks great!",
+    "what do you think about this?",
+    "yes I agree, sounds good",
+    "ok roger that",
+    "halo bro gimana kabarmu hari ini",
+    "iye bener banget katamu, setuju",
+    "thanks bro mantap banget infonya",
+    "ah yang bener nih, ku coba lagi",
+    "oke aku lagi sambil kerja, ini ngga berat kan",
+    "test testing",
+    "ok siap",
+    "ngobrol santai aja",
+    "hai apa kabar",
+    "oiya ini udah berubah",
+    "udah bener ini",
+    "ini udah jalan kok",
+    "ternyata udah berubah ya",
+    "oh iya paham",
+    "sip udah bisa",
+    "oke udah berubah",
+    "nah ini baru bener",
+    "good banget",
+    "good",
+    "mantap",
+    "keren banget",
+    "bagus banget",
+    "nice",
+    "great",
+    "tanya dulu, butuh informasi apa dari aku sebelum mulai prosesnya, perlu konfirmasi dulu kan"
+  ],
+  "RESEARCH_AND_EXPLORE": [
+    "where is handleAuth defined in the codebase?",
+    "search the repo for occurrences of JWT_SECRET",
+    "why did the build fail, here is the error log",
+    "explain how this function works and trace data flow",
+    "investigate why this 500 internal server error happens",
+    "cariin dimana fungsi handleAuth dipanggil di codebase",
+    "kenapa build gagal ya, ini log errornya tolong baca",
+    "baca file config laya-router.json dong",
+    "coba cek file server.py bagian predict dan telusuri kodenya",
+    "jelaskan cara kerja fungsi ini dan alur datanya",
+    "investigasi kenapa error 500 ini terjadi",
+    "tolong cari tahu kenapa error ini muncul di logs",
+    "kamu bisa carikan pengerjaan master itu ada di branch mana",
+    "carikan branch atau pengerjaan fitur ini",
+    "buatkan plan dan analisa dulu sebelum implementasi",
+    "analisa dulu kodenya dan buat planning",
+    "eksplorasi rencana implementasi fitur baru dan adaptasi arsitekturnya",
+    "riset dan planning apakah bisa ide atau fitur ini diimplementasikan",
+    "bagaimana cara implementasi fitur ini di pi coding agent, tolong cari tahu dan analisa"
+  ],
+  "CODING_STANDARD": [
+    "write a python script to organize downloaded files",
+    "fix bug in JSON parser when handling empty array",
+    "add new endpoint /metrics in fastapi app",
+    "implement user authentication and session management",
+    "write unit tests for helper functions",
+    "refactor this code to be cleaner and more modular",
+    "bikinin script python buat rapihin folder download otomatis",
+    "fix bug di parser JSON itu biar ngga error saat parse array",
+    "tambahin endpoint baru /metrics di fastapi",
+    "buatkan unit test untuk auth helper function",
+    "refactor kode ini agar lebih clean dan modular",
+    "implementasi fungsi upload image ke S3",
+    "bikin fitur baru untuk auth login",
+    "tulis kode untuk validasi email",
+    "oke terapkan perubahan kode ini sekarang",
+    "terapkan",
+    "eksekusi implementasi kodenya",
+    "[TASK: SPRINT]: Lakukan eksekusi Sprint untuk proyek sesuai IMPLEMENTATION_PLAN.md dan ARCHITECTURE_SPEC.md",
+    "[TASK: SPRINT] eksekusi Sprint pengerjaan fitur sesuai implementation plan dan delivery checkpoints TDD",
+    "Lakukan eksekusi Sprint dan delivery checkpoints TDD untuk implementasi endpoint, hub, dan backend code",
+    "[TASK: SPRINT] Lakukan eksekusi Sprint [DELIVERY CHECKPOINTS (TDD)] implementasi internal/api/ws_hub.go dan test"
+  ],
+  "CODE_REVIEW": [
+    "review my git diff before pushing to remote branch",
+    "check security and performance on this auth code",
+    "review PR #42 for potential bugs",
+    "audit uncommitted changes",
+    "cek review ini",
+    "tolong cek review ini dong",
+    "code review",
+    "review code",
+    "review",
+    "/review",
+    "tolong review code ini",
+    "tolong review diff aku sebelum push ke remote branch",
+    "review PR #42 dong tolong cek bug dan security",
+    "cek security di kode auth yang baru ini sebelum deploy",
+    "audit uncommitted changes sebelum commit ke git",
+    "lakukan code review komprehensif pada commit terakhir",
+    "tolong audit perubahan kode di PR ini",
+    "review diff ini",
+    "review pull request",
+    "tolong review code ini sebelum push"
+  ],
+  "HARD_ARCHITECTURE": [
+    "design a scalable multi-region distributed system architecture",
+    "evaluate database migration strategy from postgresql to horizontal sharding",
+    "investigate severe memory leak and deadlocks across concurrent worker pools",
+    "design event-driven architecture handling 100k requests per second with kafka",
+    "bagaimana desain arsitektur multi-region yang scalable dan high availability",
+    "evaluasi rencana migrasi database postgresql ke horizontal sharding",
+    "ini kok memory leak parah di worker, susah banget trace-nya, gimana solusinya",
+    "desain event-driven architecture untuk handling 100k req/s dengan kafka",
+    "analisis tradeoff antara microservices vs modular monolith untuk skala besar"
+  ]
+}

package/daemon/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.110.0
+uvicorn>=0.28.0
+numpy>=1.26.0
+laya-mlx>=0.1.0