@oxy.so/core 1.7.4 → 1.8.1

package/dist/esm/crypto/polyfill.js

@@ -13,8 +13,23 @@
  *   2. Node — backed by the built-in `node:crypto` module (`webcrypto`, else
  *      `randomFillSync`). This is what a Node runtime WITHOUT a global WebCrypto
  *      (Node 18 script entrypoints, some embedded hosts) falls back to.
- *   3. React Native — `expo-crypto.getRandomBytes` (statically imported via the
- *      per-platform `platform/crypto` module in `@oxy.so/protocol`).
+ *   3. React Native — `expo-crypto.getRandomBytes`, through the dependency-free
+ *      `@oxy.so/protocol/random` entry.
+ *
+ * # Evaluation order — this module must import NOTHING that can capture the global
+ *
+ * `@noble/hashes` 1.x reads `globalThis.crypto` exactly once, when its
+ * `crypto.js` is evaluated, and `randomBytes` uses that captured binding for
+ * the lifetime of the app. ES imports are evaluated before the importing
+ * module's body, so every module this file imports runs BEFORE the shim below
+ * is installed. This file used to import `@oxy.so/protocol`'s root entry,
+ * which reaches `@noble/curves` → `@noble/hashes` through the envelope signer:
+ * on Hermes (no `globalThis.crypto` at startup) noble captured `undefined`
+ * before the shim existed, and every identity creation on Android failed with
+ * `crypto.getRandomValues must be defined`. Its imports are therefore limited
+ * to `buffer` and `@oxy.so/protocol/random`, both free of crypto libraries,
+ * and `index.ts` imports this file first. `__tests__/polyfillOrder.test.ts`
+ * guards both halves.
  *
  * Historically step (2) delegated to `@oxy.so/protocol`'s RN-only
  * `getRandomBytesRN`, which THROWS on Node — so any Node host lacking a global
@@ -23,7 +38,7 @@
  */
 import _cjs_buffer from 'buffer';
 const { Buffer } = _cjs_buffer;
-import { getRandomBytesRN, isNodeJS } from '@oxy.so/protocol';
+import { getRandomBytesRN, isNodeJS } from '@oxy.so/protocol/random';
 const getGlobalObject = () => {
     if (typeof globalThis !== 'undefined')
         return globalThis;
@@ -112,7 +127,7 @@ const cryptoPolyfill = {
             return array;
         }
         // React Native (and any non-Node host without WebCrypto): synchronous
-        // expo-crypto via @oxy.so/protocol's RN `platform/crypto` variant.
+        // expo-crypto via @oxy.so/protocol's RN `platform/random` variant.
         const bytes = getRandomBytesRN(array.byteLength);
         const uint8View = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
         uint8View.set(bytes);

package/dist/esm/index.js

@@ -16,7 +16,10 @@
  * Every export below is NOMINAL — no `export *`, no barrels, no compat shims.
  * If a symbol does not appear here, it is NOT part of the public API.
  */
-// Ensure crypto polyfills are loaded before anything else
+// Ensure crypto polyfills are loaded before anything else. This MUST stay the
+// first import: `@noble/hashes` captures `globalThis.crypto` when it is
+// evaluated, so the shim has to exist before any module below reaches it (see
+// the evaluation-order note in `./crypto/polyfill`).
 import './crypto/polyfill.js';
 // ---------------------------------------------------------------------------
 // API client

package/dist/esm/inference/OxyInferenceClient.js

@@ -140,9 +140,14 @@ export class OxyInferenceClient {
      * both see the PUBLIC catalogue; only an internal/system application's
      * service token sees internal-only routes.
      *
-     * **`[]` is a normal answer**, and is the only answer today: the catalogue
-     * is populated by operators, and a route is not publicly exposed until
-     * somebody has reviewed the right to resell it.
+     * **`[]` is a normal answer**: a route is not publicly exposed until
+     * somebody has reviewed the right to resell it. An official application's
+     * credential also sees the internal catalogue Oxy keeps in step with
+     * Kaana automatically.
+     *
+     * Each entry's `capabilities.reasoningEfforts` lists the efforts a request
+     * may name in `reasoning.effort` (empty: none), and `releasedAt`, when
+     * present, is the date the upstream provider published the model.
      */
     async listModels(options = {}) {
         const body = await __classPrivateFieldGet(this, _OxyInferenceClient_instances, "m", _OxyInferenceClient_request).call(this, 'GET', '/v1/models', { ...(options.signal === undefined ? {} : { signal: options.signal }) });

package/dist/esm/mixins/OxyServices.utility.js

@@ -493,6 +493,7 @@ export function OxyServicesUtilityMixin(Base) {
                                 return onError(error);
                             return res.status(401).json(error);
                         }
+                        const tier = decoded.tier === 'internal' ? 'internal' : 'external';
                         // Read delegated user ID from header
                         const oxyUserIdRaw = req.headers['x-oxy-user-id'];
                         const oxyUserId = isExactNonEmptyServiceClaim(oxyUserIdRaw) ? oxyUserIdRaw : null;
@@ -513,12 +514,21 @@ export function OxyServicesUtilityMixin(Base) {
                                 return onError(error);
                             return res.status(401).json(error);
                         }
-                        // C3: a service may only act as a user when an explicit
-                        // ServiceActingAs grant exists for that (appId, userId) pair.
-                        // Without the grant we MUST refuse — silently attaching
-                        // `req.userId = oxyUserId` would let any service impersonate
-                        // any user simply by setting the header.
-                        if (oxyUserId) {
+                        // One of Oxy's own applications acts for a user without a grant:
+                        // inside the ecosystem that is trust, not consent. It still acts
+                        // with the USER's authority only — what that user may do is for the
+                        // receiving service to check.
+                        if (oxyUserId && tier === 'internal') {
+                            req.userId = oxyUserId;
+                            req.user = { id: oxyUserId };
+                            req.serviceActingAs = { userId: oxyUserId, scopes: [] };
+                        }
+                        else if (oxyUserId) {
+                            // C3: an EXTERNAL service may only act as a user when an explicit
+                            // ServiceActingAs grant exists for that (appId, userId) pair.
+                            // Without the grant we MUST refuse — silently attaching
+                            // `req.userId = oxyUserId` would let any service impersonate
+                            // any user simply by setting the header.
                             const grant = await oxyInstance.verifyServiceActingAs(appId, oxyUserId);
                             if (!grant || !grant.authorized) {
                                 logger.warn('[oxy.auth] Service token rejected — no delegation grant', {
@@ -569,6 +579,7 @@ export function OxyServicesUtilityMixin(Base) {
                             ownerAccountId,
                             scopes: Array.isArray(decoded.scopes) ? decoded.scopes : [],
                             environment,
+                            tier,
                         };
                         if (debug) {
                             logger.debug(`[oxy.auth] Service token OK app=${decoded.appName} delegateUser=${oxyUserId || '(none)'}`, {
@@ -1001,6 +1012,12 @@ export function OxyServicesUtilityMixin(Base) {
                     });
                     return;
                 }
+                // Oxy's own applications are trusted app to app; scopes are the
+                // external lane.
+                if (req.serviceApp.tier === 'internal') {
+                    next();
+                    return;
+                }
                 const appHasScope = appScopes.includes(scope);
                 const delegationHasScope = delegatedScopes.includes(scope);
                 const hasRequiredScope = req.serviceActingAs