@trymirai/uzu 0.1.21 → 0.1.23

package/napi/uzu.js

@@ -0,0 +1,95 @@
+// Auto-generated NAPI wrapper for uzu native module
+// Currently supports only Apple Silicon (arm64) on macOS
+// Other platforms may be added in future releases
+
+const { createRequire } = require('module');
+
+const require_ = createRequire(__filename);
+
+// Check for Apple Silicon support only
+if (process.platform !== 'darwin' || process.arch !== 'arm64') {
+  throw new Error(`This package only supports Apple Silicon (arm64) on macOS. Current platform: ${process.platform}-${process.arch}`);
+}
+
+let nativeBinding = null;
+
+try {
+  nativeBinding = require_('./uzu.node');
+} catch (e) {
+  throw new Error(`Failed to load native binding: ${e.message}`);
+}
+
+// Re-export all runtime exports
+const {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+} = nativeBinding;
+
+module.exports = {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+};

package/napi/uzu.mjs

@@ -0,0 +1,61 @@
+// Auto-generated NAPI wrapper for uzu native module
+// Currently supports only Apple Silicon (arm64) on macOS
+// Other platforms may be added in future releases
+
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+// Check for Apple Silicon support only
+if (process.platform !== 'darwin' || process.arch !== 'arm64') {
+  throw new Error(`This package only supports Apple Silicon (arm64) on macOS. Current platform: ${process.platform}-${process.arch}`);
+}
+
+let nativeBinding = null;
+
+try {
+  nativeBinding = require('./uzu.node');
+} catch (e) {
+  throw new Error(`Failed to load native binding: ${e.message}`);
+}
+
+// Re-export all runtime exports as named exports  
+export const {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+} = nativeBinding;
+
+// Also provide default export
+export default nativeBinding;

package/package.json

@@ -1,41 +1,102 @@
 {
-  "name": "@trymirai/uzu",
-  "version": "0.1.21",
-  "private": false,
-  "main": "uzu.node",
-  "types": "uzu.d.ts",
-  "packageManager": "pnpm@10.14.0",
-  "scripts": {
-    "quick-start": "ts-node examples/quick-start.ts",
-    "chat": "ts-node examples/chat.ts",
-    "summarisation": "ts-node examples/summarisation.ts",
-    "classification": "ts-node examples/classification.ts"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "3.1.2",
-    "@types/node": "24.2.0",
-    "@types/progress": "2.0.7",
-    "eslint": "9.33.0",
-    "ts-node": "10.9.2",
-    "typescript": "5.9.2",
-    "typescript-eslint": "8.40.0"
-  },
-  "dependencies": {
-    "progress": "2.0.3"
-  },
-  "napi": {
-    "binaryName": "uzu"
-  },
-  "os": [
-    "darwin"
-  ],
+  "author": "Mirai Tech Inc. <contact@getmirai.co>",
   "cpu": [
     "arm64"
   ],
+  "description": "A high-performance inference engine for AI models",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "types": "./index.d.mts",
+      "default": "./index.mjs"
+    },
+    "./bridging/*.mjs": {
+      "default": "./bridging/*.mjs"
+    },
+    "./bridging/*.js": {
+      "default": "./bridging/*.js"
+    },
+    "./bridging/*": {
+      "import": "./bridging/*.mjs",
+      "require": "./bridging/*.js"
+    },
+    "./error": {
+      "import": "./error.mjs",
+      "require": "./error.js"
+    },
+    "./error.js": {
+      "default": "./error.js"
+    },
+    "./error.mjs": {
+      "default": "./error.mjs"
+    },
+    "./index": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    },
+    "./index.js": {
+      "default": "./index.js"
+    },
+    "./index.mjs": {
+      "default": "./index.mjs"
+    },
+    "./interactors/*.mjs": {
+      "default": "./interactors/*.mjs"
+    },
+    "./interactors/*.js": {
+      "default": "./interactors/*.js"
+    },
+    "./interactors/*": {
+      "import": "./interactors/*.mjs",
+      "require": "./interactors/*.js"
+    },
+    "./utilities/*.mjs": {
+      "default": "./utilities/*.mjs"
+    },
+    "./utilities/*.js": {
+      "default": "./utilities/*.js"
+    },
+    "./utilities/*": {
+      "import": "./utilities/*.mjs",
+      "require": "./utilities/*.js"
+    },
+    "./version": {
+      "import": "./version.mjs",
+      "require": "./version.js"
+    },
+    "./version.js": {
+      "default": "./version.js"
+    },
+    "./version.mjs": {
+      "default": "./version.mjs"
+    }
+  },
   "files": [
-    "uzu.node",
-    "uzu.d.ts",
-    "package.json",
-    "README.md"
-  ]
+    "**/*"
+  ],
+  "license": "MIT",
+  "main": "./index.js",
+  "name": "@trymirai/uzu",
+  "os": [
+    "darwin"
+  ],
+  "packageManager": "pnpm@10.18.1",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": "github:trymirai/uzu-ts",
+  "scripts": {
+    "build": "./scripts/build",
+    "fix": "./scripts/format",
+    "format": "./scripts/format",
+    "lint": "./scripts/lint",
+    "tsn": "ts-node -r tsconfig-paths/register"
+  },
+  "type": "commonjs",
+  "types": "./index.d.ts",
+  "version": "0.1.23"
 }

package/src/bridging/classificationFeature.ts

@@ -0,0 +1,20 @@
+import { ClassificationFeature as NapiClassificationFeature } from '../napi/uzu';
+import { ToNapi } from './napi';
+
+export class ClassificationFeature implements ToNapi<NapiClassificationFeature> {
+    readonly name: string;
+    readonly values: string[];
+
+    constructor(name: string, values: string[]) {
+        this.name = name;
+        this.values = values;
+    }
+
+    toNapi(): NapiClassificationFeature {
+        const result: NapiClassificationFeature = {
+            name: this.name,
+            values: this.values,
+        };
+        return result;
+    }
+}

package/src/bridging/config.ts

@@ -0,0 +1,60 @@
+import { Config as NapiConfig } from '../napi/uzu';
+import { ContextLength } from './contextLength';
+import { ToNapi } from './napi';
+import { PrefillStepSize } from './prefillStepSize';
+import { Preset } from './preset';
+import { SamplingSeed } from './samplingSeed';
+
+export class Config implements ToNapi<NapiConfig> {
+    readonly preset: Preset;
+    readonly prefillStepSize: PrefillStepSize;
+    readonly contextLength: ContextLength;
+    readonly samplingSeed: SamplingSeed;
+
+    constructor(
+        preset: Preset,
+        prefillStepSize: PrefillStepSize,
+        contextLength: ContextLength,
+        samplingSeed: SamplingSeed,
+    ) {
+        this.preset = preset;
+        this.prefillStepSize = prefillStepSize;
+        this.contextLength = contextLength;
+        this.samplingSeed = samplingSeed;
+    }
+
+    static default(): Config {
+        return new Config(
+            Preset.general(),
+            PrefillStepSize.default(),
+            ContextLength.default(),
+            SamplingSeed.default(),
+        );
+    }
+
+    withPreset(preset: Preset): Config {
+        return new Config(preset, this.prefillStepSize, this.contextLength, this.samplingSeed);
+    }
+
+    withPrefillStepSize(prefillStepSize: PrefillStepSize): Config {
+        return new Config(this.preset, prefillStepSize, this.contextLength, this.samplingSeed);
+    }
+
+    withContextLength(contextLength: ContextLength): Config {
+        return new Config(this.preset, this.prefillStepSize, contextLength, this.samplingSeed);
+    }
+
+    withSamplingSeed(samplingSeed: SamplingSeed): Config {
+        return new Config(this.preset, this.prefillStepSize, this.contextLength, samplingSeed);
+    }
+
+    toNapi(): NapiConfig {
+        const napiConfig: NapiConfig = {
+            preset: this.preset.toNapi(),
+            prefillStepSize: this.prefillStepSize.toNapi(),
+            contextLength: this.contextLength.toNapi(),
+            samplingSeed: this.samplingSeed.toNapi(),
+        };
+        return napiConfig;
+    }
+}

package/src/bridging/contextLength.ts

@@ -0,0 +1,29 @@
+import { ContextLength as NapiContextLength } from '../napi/uzu';
+import { ToNapi } from './napi';
+
+export class ContextLength implements ToNapi<NapiContextLength> {
+    private readonly napiContextLength: NapiContextLength;
+
+    private constructor(napiContextLength: NapiContextLength) {
+        this.napiContextLength = napiContextLength;
+    }
+
+    static default(): ContextLength {
+        const napiContextLength: NapiContextLength = { type: 'Default' };
+        return new ContextLength(napiContextLength);
+    }
+
+    static maximal(): ContextLength {
+        const napiContextLength: NapiContextLength = { type: 'Maximal' };
+        return new ContextLength(napiContextLength);
+    }
+
+    static custom(length: number): ContextLength {
+        const napiContextLength: NapiContextLength = { type: 'Custom', length };
+        return new ContextLength(napiContextLength);
+    }
+
+    toNapi(): NapiContextLength {
+        return this.napiContextLength;
+    }
+}

package/src/bridging/downloadHandle.ts

@@ -0,0 +1,41 @@
+import { ModelDownloadHandle as NapiModelDownloadHandle } from '../napi/uzu';
+import { DownloadProgressUpdate } from './downloadProgressUpdate';
+import { DownloadState } from './downloadState';
+
+export class DownloadHandle {
+    private readonly napiDownloadHandle: NapiModelDownloadHandle;
+
+    constructor(napiDownloadHandle: NapiModelDownloadHandle) {
+        this.napiDownloadHandle = napiDownloadHandle;
+    }
+
+    identifier(): string {
+        return this.napiDownloadHandle.identifier();
+    }
+
+    async state(): Promise<DownloadState> {
+        const napiDownloadState = await this.napiDownloadHandle.state();
+        return DownloadState.fromNapi(napiDownloadState);
+    }
+
+    async download(): Promise<void> {
+        await this.napiDownloadHandle.download();
+    }
+
+    async pause(): Promise<void> {
+        await this.napiDownloadHandle.pause();
+    }
+
+    async delete(): Promise<void> {
+        await this.napiDownloadHandle.delete();
+    }
+
+    progressUpdate(): AsyncIterable<DownloadProgressUpdate> {
+        const source = this.napiDownloadHandle.progress();
+        return (async function* () {
+            for await (const update of source) {
+                yield DownloadProgressUpdate.fromNapi(update);
+            }
+        })();
+    }
+}

package/src/bridging/downloadProgressUpdate.ts

@@ -0,0 +1,21 @@
+import { ProgressUpdate as NapiProgressUpdate } from '../napi/uzu';
+
+export class DownloadProgressUpdate {
+    readonly completedBytes: number;
+    readonly totalBytes: number | null;
+    readonly progress: number;
+
+    private constructor(completedBytes: number, totalBytes: number | null, progress: number) {
+        this.completedBytes = completedBytes;
+        this.totalBytes = totalBytes;
+        this.progress = progress;
+    }
+
+    static fromNapi(napiDownloadProgress: NapiProgressUpdate): DownloadProgressUpdate {
+        return new DownloadProgressUpdate(
+            napiDownloadProgress.completedBytes,
+            napiDownloadProgress.totalBytes ?? null,
+            napiDownloadProgress.progress,
+        );
+    }
+}

package/src/bridging/downloadState.ts

@@ -0,0 +1,59 @@
+import { EngineError, EngineErrorCode } from '../error';
+import {
+    ModelDownloadPhase as NapiModelDownloadPhase,
+    ModelDownloadState as NapiModelDownloadState,
+} from '../napi/uzu';
+
+export enum DownloadPhase {
+    NotDownloaded = 'NotDownloaded',
+    Downloading = 'Downloading',
+    Paused = 'Paused',
+    Downloaded = 'Downloaded',
+    Error = 'Error',
+}
+
+export class DownloadState {
+    readonly totalKbytes: number;
+    readonly downloadedKbytes: number;
+    readonly phase: DownloadPhase;
+    readonly error: string | null;
+
+    private constructor(
+        totalKbytes: number,
+        downloadedKbytes: number,
+        phase: DownloadPhase,
+        error: string | null,
+    ) {
+        this.totalKbytes = totalKbytes;
+        this.downloadedKbytes = downloadedKbytes;
+        this.phase = phase;
+        this.error = error;
+    }
+
+    private static napiPhaseToDownloadPhase(napiPhase: NapiModelDownloadPhase): DownloadPhase {
+        switch (napiPhase) {
+            case 0:
+                return DownloadPhase.NotDownloaded;
+            case 1:
+                return DownloadPhase.Downloading;
+            case 2:
+                return DownloadPhase.Paused;
+            case 3:
+                return DownloadPhase.Downloaded;
+            case 4:
+                return DownloadPhase.Error;
+            default:
+                throw new EngineError(EngineErrorCode.UnexpectedDownloadPhase);
+        }
+    }
+
+    static fromNapi(napiDownloadState: NapiModelDownloadState): DownloadState {
+        const phase = DownloadState.napiPhaseToDownloadPhase(napiDownloadState.phase);
+        return new DownloadState(
+            napiDownloadState.totalKbytes,
+            napiDownloadState.downloadedKbytes,
+            phase,
+            napiDownloadState.error ?? null,
+        );
+    }
+}

package/src/bridging/engine.ts

@@ -0,0 +1,97 @@
+import { EngineError, EngineErrorCode, unwrapOrThrow } from '../error';
+import { EngineInteractor } from '../interactors/engineInteractor';
+import { Engine as NapiEngine, ModelID as NapiModelID } from '../napi/uzu';
+import { readEnv } from '../utilities/env';
+import { Config } from './config';
+import { DownloadHandle } from './downloadHandle';
+import { LicenseStatus, licenseStatusFromNapiLicenseStatus } from './licenseStatus';
+import { Model, ModelKind, ModelType } from './model';
+import { Session } from './session';
+
+export class Engine {
+    private readonly napiEngine: NapiEngine;
+
+    private constructor(napiEngine: NapiEngine) {
+        this.napiEngine = napiEngine;
+    }
+
+    static async load(apiKey: string | undefined = undefined): Promise<Engine> {
+        const resolvedApiKey = unwrapOrThrow(
+            apiKey ?? readEnv('MIRAI_API_KEY'),
+            EngineErrorCode.APIKeyNotFound,
+        );
+
+        const napiEngine = new NapiEngine();
+
+        const napiLicenseStatus = await napiEngine.activate(resolvedApiKey);
+        const licenseStatus = licenseStatusFromNapiLicenseStatus(napiLicenseStatus);
+        switch (licenseStatus) {
+            case LicenseStatus.Activated:
+            case LicenseStatus.GracePeriodActive:
+                break;
+            default:
+                throw new EngineError(EngineErrorCode.LicenseNotActivated);
+        }
+
+        return new Engine(napiEngine);
+    }
+
+    static create(apiKey: string | undefined = undefined): EngineInteractor {
+        const enginePromise = (async () => {
+            return await Engine.load(apiKey);
+        })();
+        return new EngineInteractor(enginePromise);
+    }
+
+    async models(types: ModelType[] | null = null, kinds: ModelKind[] | null = null): Promise<Model[]> {
+        function isTypeAllowed(type: ModelType): boolean {
+            return types === null || types.includes(type);
+        }
+
+        function isKindAllowed(kind: ModelKind): boolean {
+            return kinds === null || kinds.includes(kind);
+        }
+
+        let results: Model[] = [];
+        if (isTypeAllowed(ModelType.Local) && isKindAllowed(ModelKind.Text)) {
+            const napiLocalModels = this.napiEngine.getLocalModels();
+            results.push(...napiLocalModels.map(Model.fromNapiLocalModel));
+        }
+        if (isTypeAllowed(ModelType.Cloud) && isKindAllowed(ModelKind.Text)) {
+            const napiCloudModels = await this.napiEngine.getCloudModels();
+            results.push(...napiCloudModels.map(Model.fromNapiCloudModel));
+        }
+        return results;
+    }
+
+    async model(repoId: string): Promise<Model> {
+        const models = await this.models();
+        const model = models.find((model) => model.repoId === repoId);
+        return unwrapOrThrow(model, EngineErrorCode.ModelNotFound);
+    }
+
+    downloadHandle(model: Model): DownloadHandle {
+        if (model.type !== ModelType.Local) {
+            throw new EngineError(EngineErrorCode.ExpectedLocalModel);
+        }
+        return new DownloadHandle(this.napiEngine.downloadHandle(model.repoId));
+    }
+
+    private static napiModelId(model: Model): NapiModelID {
+        switch (model.type) {
+            case ModelType.Local:
+                return { type: 'Local', id: model.repoId };
+            case ModelType.Cloud:
+                return { type: 'Cloud', id: model.repoId };
+        }
+    }
+
+    session(model: Model, config: Config = Config.default()): Session {
+        if (model.kind !== ModelKind.Text) {
+            throw new EngineError(EngineErrorCode.ExpectedTextModel);
+        }
+        const napiModelId = Engine.napiModelId(model);
+        const napiConfig = config.toNapi();
+        return new Session(this.napiEngine.createSession(napiModelId, napiConfig));
+    }
+}

package/src/bridging/finishReason.ts

@@ -0,0 +1,6 @@
+export enum FinishReason {
+    Stop = 0,
+    Length = 1,
+    Cancelled = 2,
+    ContextLimitReached = 3,
+}

package/src/bridging/input.ts

@@ -0,0 +1,29 @@
+import { Input as NapiInput, Message as NapiMessage } from '../napi/uzu';
+import { Message } from './message';
+import { ToNapi } from './napi';
+
+export class Input implements ToNapi<NapiInput> {
+    private readonly napiInput: NapiInput;
+
+    private constructor(napiInput: NapiInput) {
+        this.napiInput = napiInput;
+    }
+
+    static text(text: string): Input {
+        const napiInput: NapiInput = { type: 'Text', text };
+        return new Input(napiInput);
+    }
+
+    static messages(messages: Message[]): Input {
+        const napiMessages: NapiMessage[] = messages.map((message) => message.toNapi());
+        const napiInput: NapiInput = {
+            type: 'Messages',
+            messages: napiMessages,
+        };
+        return new Input(napiInput);
+    }
+
+    toNapi(): NapiInput {
+        return this.napiInput;
+    }
+}