@ariacompute/engine-rn 1.15.0 → 1.16.0

package/README.md

@@ -20,10 +20,13 @@ ModelScope; `site` defaults to `https://ariacompute.com`) into
 `~/.ariacompute/models/{model}` and then loads it. Dashboard is not used. A
 Dashboard `sk-` / `bfvk-` token is ignored for hub auth. Token is optional for
 public models. Gated files: pass `hfToken` / `modelscopeApiToken` (same as
-`aria-engine auth`); if omitted, reads `~/.ariacompute/config.yml`. A valid
-cached bundle is reused without re-downloading.
+`aria-engine auth`); if omitted, reads `~/.ariacompute/config.yml`. Instance
+`auth` is in-memory only (does not write that file). A valid cached bundle is
+reused without re-downloading.
 
 ```js
 const eng = await AriaEngine.open("gemma-4-e2b-it_q4");
-const gated = await AriaEngine.open("gemma-4-e2b-it_q4", { hfToken: "hf_..." });
+const gated = new AriaEngine();
+gated.auth({ hf_token: "hf_..." });
+await gated.open("gemma-4-e2b-it_q4");
 ```

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@ariacompute/engine-rn",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "React Native binding for Aria Engine",
   "main": "src/index.js",
   "license": "MIT",
   "peerDependencies": {
     "react-native": ">=0.72.0"
+  },
+  "scripts": {
+    "test": "node --test test/auth.test.cjs"
   }
 }

package/src/auth.js

@@ -0,0 +1,115 @@
+/** Instance-level Engine auth (in-memory; does not write config.yml). */
+
+const INTL_CLOUD = 'https://gateway.ariacompute.com';
+const INTL_SITE = 'https://ariacompute.com';
+const INTL_UPGRADE = 'https://github.com/ariacompute';
+const CN_CLOUD = 'https://gateway.ariacompute.cn';
+const CN_SITE = 'https://ariacompute.cn';
+const CN_UPGRADE = 'https://gitee.com/ariacompute';
+
+function defaultAuthConfig() {
+  return {
+    cloud_api_key: '',
+    cloud_url: '',
+    site_url: '',
+    upgrade_url: '',
+    hybrid_mode: 'balance',
+    hybrid_execution: 'hybrid',
+    hybrid_semantic: true,
+    hybrid_semantic_timeout_ms: 800,
+    hybrid_semantic_cache_size: 512,
+    compute: 'auto',
+    hf_token: '',
+    modelscope_api_token: '',
+  };
+}
+
+function gatewayRegion(url) {
+  const lower = (url || '').toLowerCase();
+  if (lower.includes('ariacompute.cn') || lower.includes('gitee.com/ariacompute')) return 'cn';
+  if (lower.includes('ariacompute.com') || lower.includes('github.com/ariacompute')) return 'intl';
+  return undefined;
+}
+
+function pairUrls(region) {
+  return region === 'cn' ? [CN_CLOUD, CN_SITE, CN_UPGRADE] : [INTL_CLOUD, INTL_SITE, INTL_UPGRADE];
+}
+
+function fillAuthUrls(cfg) {
+  const out = { ...cfg };
+  const region =
+    gatewayRegion(out.site_url) || gatewayRegion(out.cloud_url) || gatewayRegion(out.upgrade_url);
+  if (!region) return out;
+  const [cloud, site, upgrade] = pairUrls(region);
+  if (!out.cloud_url) out.cloud_url = cloud;
+  if (!out.site_url) out.site_url = site;
+  if (!out.upgrade_url) out.upgrade_url = upgrade;
+  return out;
+}
+
+function localePrefersCn() {
+  const lang = `${process.env.LANG || ''}${process.env.LC_ALL || ''}`.toLowerCase();
+  return lang.includes('zh') || lang.includes('.cn') || lang.startsWith('cn');
+}
+
+const authHooks = {
+  probeDashboard: () => false,
+};
+
+function detectGatewayPair(apiKey) {
+  const key = (apiKey || '').trim();
+  const first = localePrefersCn() ? 'cn' : 'intl';
+  const second = first === 'cn' ? 'intl' : 'cn';
+  for (const region of [first, second]) {
+    const [cloud, site, upgrade] = pairUrls(region);
+    if (key && authHooks.probeDashboard(site, key)) return [cloud, site, upgrade];
+  }
+  return pairUrls(first);
+}
+
+function applyAuth(existing, updates) {
+  const out = { ...existing };
+  for (const [k, v] of Object.entries(updates || {})) {
+    if (v === undefined) continue;
+    out[k] = v;
+  }
+  if (!['cost', 'balance', 'intelligence'].includes(out.hybrid_mode)) {
+    throw new Error(`invalid hybrid_mode: ${out.hybrid_mode}`);
+  }
+  if (!['hybrid', 'device', 'cloud'].includes(out.hybrid_execution)) {
+    throw new Error(`invalid hybrid_execution: ${out.hybrid_execution}`);
+  }
+  if (!['auto', 'cpu', 'cuda'].includes(out.compute)) {
+    throw new Error(`invalid compute: ${out.compute}`);
+  }
+  const timeout = Number(out.hybrid_semantic_timeout_ms);
+  const cache = Number(out.hybrid_semantic_cache_size);
+  if (!Number.isInteger(timeout) || !Number.isInteger(cache) || timeout <= 0 || cache <= 0) {
+    throw new Error('hybrid_semantic_timeout_ms / cache_size must be positive integers');
+  }
+  out.hybrid_semantic = Boolean(out.hybrid_semantic);
+  out.hybrid_semantic_timeout_ms = timeout;
+  out.hybrid_semantic_cache_size = cache;
+  const filled = fillAuthUrls(out);
+  if (filled.cloud_api_key && !(filled.cloud_url && filled.site_url && filled.upgrade_url)) {
+    const [cloud, site, upgrade] = detectGatewayPair(filled.cloud_api_key);
+    if (!filled.cloud_url) filled.cloud_url = cloud;
+    if (!filled.site_url) filled.site_url = site;
+    if (!filled.upgrade_url) filled.upgrade_url = upgrade;
+  }
+  return filled;
+}
+
+module.exports = {
+  INTL_CLOUD,
+  INTL_SITE,
+  INTL_UPGRADE,
+  CN_CLOUD,
+  CN_SITE,
+  CN_UPGRADE,
+  defaultAuthConfig,
+  fillAuthUrls,
+  applyAuth,
+  authHooks,
+  detectGatewayPair,
+};

package/src/index.js

@@ -8,6 +8,10 @@
  * `~/.ariacompute/models/{model}`, then loads via native init.
  */
 import { NativeModules } from 'react-native';
+import {
+  defaultAuthConfig,
+  applyAuth,
+} from './auth.js';
 
 const AriaEngineModule = NativeModules.AriaEngine;
 
@@ -421,14 +425,49 @@ async function ensureFfiLib(site) {
 export class AriaEngine {
   constructor(bundlePath) {
     this.bundlePath = bundlePath;
+    this.cfg = defaultAuthConfig();
+    this.opts = {};
     // NativeModules.AriaEngine.init(bundlePath) when linked.
   }
 
-  static async open(modelRef, opts = {}) {
+  auth(updates) {
+    this.cfg = applyAuth(this.cfg, updates);
+    return this;
+  }
+
+  authStatus() {
+    return { ...this.cfg };
+  }
+
+  authClear() {
+    this.cfg = defaultAuthConfig();
+    return this;
+  }
+
+  async open(modelRef) {
+    const opts = {
+      ...this.opts,
+      site: this.cfg.site_url || this.opts.site,
+      hfToken: this.cfg.hf_token || this.opts.hfToken,
+      modelscopeApiToken: this.cfg.modelscope_api_token || this.opts.modelscopeApiToken,
+    };
     await ensureFfiLib(opts.site);
-    if (isLocalRef(modelRef)) return new AriaEngine(modelRef);
-    const bundle = await downloadModel(modelRef, opts);
-    return new AriaEngine(bundle);
+    this.bundlePath = isLocalRef(modelRef) ? modelRef : await downloadModel(modelRef, opts);
+    return this;
+  }
+
+  static async open(modelRef, opts = {}) {
+    const eng = new AriaEngine();
+    eng.opts = opts;
+    if (opts.site || opts.hfToken || opts.modelscopeApiToken) {
+      eng.auth({
+        site_url: opts.site,
+        hf_token: opts.hfToken,
+        modelscope_api_token: opts.modelscopeApiToken,
+      });
+    }
+    await eng.open(modelRef);
+    return eng;
   }
 
   async complete(messages, options = { max_tokens: 16 }, tools = []) {

package/test/auth.test.cjs

@@ -0,0 +1,106 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  applyAuth,
+  defaultAuthConfig,
+  fillAuthUrls,
+  authHooks,
+  CN_CLOUD,
+  CN_SITE,
+  CN_UPGRADE,
+} = require('../src/auth.js');
+
+test('auth defaults', () => {
+  const cfg = defaultAuthConfig();
+  assert.equal(cfg.hybrid_mode, 'balance');
+  assert.equal(cfg.hybrid_execution, 'hybrid');
+  assert.equal(cfg.hybrid_semantic, true);
+  assert.equal(cfg.hybrid_semantic_timeout_ms, 800);
+  assert.equal(cfg.hybrid_semantic_cache_size, 512);
+  assert.equal(cfg.compute, 'auto');
+});
+
+test('auth invalid enum', () => {
+  assert.throws(() => applyAuth(defaultAuthConfig(), { hybrid_mode: 'fast' }));
+  assert.throws(() => applyAuth(defaultAuthConfig(), { hybrid_execution: 'local' }));
+  assert.throws(() => applyAuth(defaultAuthConfig(), { compute: 'gpu' }));
+});
+
+test('auth fills urls from cn site', () => {
+  const got = fillAuthUrls({ site_url: CN_SITE, cloud_url: '', upgrade_url: '' });
+  assert.equal(got.cloud_url, CN_CLOUD);
+  assert.equal(got.upgrade_url, CN_UPGRADE);
+});
+
+test('auth instance all fields via applyAuth', () => {
+  const st = applyAuth(defaultAuthConfig(), {
+    cloud_api_key: 'sk-test',
+    cloud_url: CN_CLOUD,
+    site_url: CN_SITE,
+    upgrade_url: CN_UPGRADE,
+    hybrid_mode: 'cost',
+    hybrid_execution: 'device',
+    hybrid_semantic: false,
+    hybrid_semantic_timeout_ms: 250,
+    hybrid_semantic_cache_size: 16,
+    compute: 'cpu',
+    hf_token: 'hf_abc',
+    modelscope_api_token: 'ms_xyz',
+  });
+  assert.equal(st.cloud_api_key, 'sk-test');
+  assert.equal(st.hybrid_mode, 'cost');
+  assert.equal(st.hf_token, 'hf_abc');
+});
+
+test('auth partial merge', () => {
+  const once = applyAuth(defaultAuthConfig(), { hf_token: 'hf_one', hybrid_mode: 'intelligence' });
+  const st = applyAuth(once, { compute: 'cuda' });
+  assert.equal(st.hf_token, 'hf_one');
+  assert.equal(st.hybrid_mode, 'intelligence');
+  assert.equal(st.compute, 'cuda');
+});
+
+test('auth invalid enum leaves state', () => {
+  const once = applyAuth(defaultAuthConfig(), { hybrid_mode: 'cost' });
+  assert.throws(() => applyAuth(once, { hybrid_mode: 'nope' }));
+  assert.equal(once.hybrid_mode, 'cost');
+});
+
+test('auth fills urls from site tld', () => {
+  const st = applyAuth(defaultAuthConfig(), { site_url: 'https://ariacompute.cn' });
+  assert.equal(st.cloud_url, CN_CLOUD);
+  assert.equal(st.upgrade_url, CN_UPGRADE);
+});
+
+test('auth does not write config.yml', () => {
+  const prev = process.env.ARIA_COMPUTE_HOME;
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'aria-rn-auth-'));
+  process.env.ARIA_COMPUTE_HOME = home;
+  try {
+    applyAuth(defaultAuthConfig(), {
+      cloud_api_key: 'sk-test',
+      site_url: 'https://ariacompute.com',
+      hf_token: 'hf_x',
+    });
+    assert.equal(fs.existsSync(path.join(home, 'config.yml')), false);
+  } finally {
+    if (prev === undefined) delete process.env.ARIA_COMPUTE_HOME;
+    else process.env.ARIA_COMPUTE_HOME = prev;
+  }
+});
+
+test('auth detect urls from key mocked', () => {
+  const prev = authHooks.probeDashboard;
+  authHooks.probeDashboard = (site) => String(site).includes('ariacompute.cn');
+  try {
+    const st = applyAuth(defaultAuthConfig(), { cloud_api_key: 'sk-region' });
+    assert.equal(st.site_url, CN_SITE);
+    assert.equal(st.cloud_url, CN_CLOUD);
+    assert.equal(st.upgrade_url, CN_UPGRADE);
+  } finally {
+    authHooks.probeDashboard = prev;
+  }
+});